chore: update comments on permissions

Signed-off-by: Zomatree <me@zomatree.live>

.github/ISSUE_TEMPLATE/bug.yml

@@ -0,0 +1,147 @@
+name: Bug Report
+description: Report a bug in Stoat — please fill out every required field to help us triage quickly.
+title: "[Bug]: "
+labels:
+  - bug
+  - unconfirmed
+
+body:
+  # ── Thank you section ────────────────────────────────────────────────────────
+  - type: markdown
+    attributes:
+      value: |
+        **Thank you for taking the time to report a bug for Stoat!**
+
+        Please follow the instructions below and provide as much detail as possible to help us understand and reproduce the issue.
+
+  # ── Pre-flight checks ────────────────────────────────────────────────────────
+  - type: checkboxes
+    id: preflight
+    attributes:
+      label: Pre-flight checklist
+      description: Please confirm all of the following before submitting.
+      options:
+        - label: I am on the latest available version of Stoat.
+          required: true
+        - label: I searched existing issues and did not find a duplicate.
+          required: true
+        - label: This is a bug report, not a support question or feature request.
+          required: true
+
+  # ── Bug description ──────────────────────────────────────────────────────────
+  - type: textarea
+    id: description
+    attributes:
+      label: Bug description
+      description: >
+        What happened? What did you expect to happen instead?
+        Keep this brief — detailed steps go in the next field.
+      placeholder: "Example: When I open a DM thread, new messages from the other person do not appear unless I reload the page."
+    validations:
+      required: true
+
+  # ── Steps to reproduce ───────────────────────────────────────────────────────
+  - type: textarea
+    id: steps
+    attributes:
+      label: Steps to reproduce
+      description: >
+        Provide a numbered list of every step needed to trigger the bug.
+        The clearer this is, the faster we can fix it.
+      placeholder: |
+        1. Log in to Stoat on the web client.
+        2. Open a direct message conversation.
+        3. Ask the other person to send a message.
+        4. Observe that the message does not appear without reloading.
+    validations:
+      required: true
+
+  # ── Expected behavior ────────────────────────────────────────────────────────
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected behavior
+      description: What should have happened?
+      placeholder: "New messages should appear in real time without a page reload."
+    validations:
+      required: true
+
+  # ── Client / platform ────────────────────────────────────────────────────────
+  - type: dropdown
+    id: platform
+    attributes:
+      label: Client / platform
+      description: Which Stoat client are you using?
+      options:
+        - Web (browser)
+        - Stoat for Desktop
+        - Android
+        - iOS
+        - Self-hosted server
+    validations:
+      required: true
+
+  # ── Client version ───────────────────────────────────────────────────────────
+  - type: input
+    id: version
+    attributes:
+      label: Client version
+      description: >
+        Find this in **Settings**. For the web client, include the build
+        number shown in the footer or About page.
+      placeholder: "e.g. Stoat for Desktop 1.3.0 or 0.2.1 (2025-10-10)"
+    validations:
+      required: true
+
+  # ── OS / browser details ─────────────────────────────────────────────────────
+  - type: input
+    id: os
+    attributes:
+      label: OS / browser details
+      description: Your operating system and, for web bugs, your browser and its version.
+      placeholder: "e.g. Windows 11, Chrome 121  or  macOS 14.3, Stoat for Desktop 1.3.0  or  Android 14"
+    validations:
+      required: true
+
+  # ── Reproducibility ──────────────────────────────────────────────────────────
+  - type: dropdown
+    id: reproducibility
+    attributes:
+      label: Reproducibility
+      description: How consistently does this bug occur?
+      options:
+        - Always
+        - Usually
+        - Rarely
+        - Only once
+        - Unknown
+    validations:
+      required: true
+
+  # ── Screenshots or video ─────────────────────────────────────────────────────
+  - type: textarea
+    id: screenshots
+    attributes:
+      label: Screenshots or video
+      description: Paste images or drag-and-drop a screen recording here. GitHub accepts common image and video formats.
+    validations:
+      required: false
+
+  # ── Additional context ───────────────────────────────────────────────────────
+  - type: textarea
+    id: additional
+    attributes:
+      label: Additional context
+      description: >
+        Anything else that might help: workarounds you found, links to related issues,
+        self-hosted configuration details (Redis, MongoDB, LiveKit, SMTP), network environment, etc.
+    validations:
+      required: false
+
+  # ── Closing note ─────────────────────────────────────────────────────────────
+  - type: markdown
+    attributes:
+      value: |
+        ---
+        A maintainer will review your report. Please watch for follow-up questions — issues
+        that go unanswered are harder to resolve and may be closed after 30 days of inactivity.

.github/pull_request_template.md

@@ -0,0 +1,24 @@
+<!-- Describe your changes -->
+
+Fixes # (issue)
+
+## How was this PR tested?
+
+<!-- What did you do to test your changes? -->
+
+- [ ] Test A
+- [ ] Test B
+
+## Checklist:
+
+- [ ] I have carefully read [the contributing guidelines](https://developers.stoat.chat/developing/contrib/)
+- [ ] I have performed a self-review of my own code
+- [ ] I have made corresponding changes to the documentation if applicable
+- [ ] I have no unrelated changes in the PR
+- [ ] I have confirmed that any new dependencies are strictly necessary
+- [ ] I have written tests for new code (if applicable)
+- [ ] I have followed naming conventions/patterns in the surrounding code
+
+## Please declare, if any, LLM usage involved in creating this PR
+
+...

.github/workflows/book.yml

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

.github/workflows/docker-cleanup.yaml

@@ -0,0 +1,46 @@
+name: Docker PR Image Cleanup
+
+on:
+  pull_request:
+    types:
+      - closed
+
+permissions:
+  contents: read
+  packages: write
+
+concurrency:
+  group: docker-cleanup-${{ github.event.pull_request.number }}
+  cancel-in-progress: false
+
+jobs:
+  cleanup:
+    runs-on: ubuntu-latest
+    if: ${{ !github.event.pull_request.head.repo.fork }}
+    strategy:
+      fail-fast: false
+      matrix:
+        package:
+          - base
+          - api
+          - events
+          - file-server
+          - proxy
+          - gifbox
+          - crond
+          - pushd
+          - voice-ingress
+    steps:
+      - env:
+          GH_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          ORG: stoatchat
+          PACKAGE: ${{ matrix.package }}
+          TAG: pr-${{ github.event.pull_request.number }}
+        run: |
+          set -euo pipefail
+          gh api --paginate \
+            "/orgs/${ORG}/packages/container/${PACKAGE}/versions" \
+            --jq ".[] | select(.metadata.container.tags | index(\"${TAG}\")) | .id" \
+          | while read -r id; do
+              gh api -X DELETE "/orgs/${ORG}/packages/container/${PACKAGE}/versions/${id}"
+            done

.github/workflows/docker.yaml

@@ -5,20 +5,21 @@ on:
     tags:
       - "*"
   pull_request:
-    branches:
-      - "main"
-    paths:
-      - "Dockerfile"
+  workflow_dispatch:
 
 permissions:
   contents: read
   packages: write
 
+concurrency:
+  group: ${{ github.head_ref || github.ref }}
+  cancel-in-progress: true
+
 jobs:
   base:
-    name: Test base image build
-    runs-on: ubuntu-latest
-    if: github.event_name == 'pull_request'
+    name: Test base image build (fork)
+    runs-on: arc-runner-set
+    if: github.event_name == 'pull_request' && github.event.pull_request.head.repo.fork
     steps:
       # Configure build environment
       - name: Checkout
@@ -38,8 +39,8 @@ jobs:
           cache-to: type=gha,scope=buildx-base-multi-arch,mode=max
 
   publish:
-    runs-on: self-hosted
-    if: github.event_name != 'pull_request'
+    runs-on: arc-runner-set
+    if: ${{ github.event_name != 'pull_request' || !github.event.pull_request.head.repo.fork }}
     name: Publish Docker images
     steps:
       # Configure build environment
@@ -49,13 +50,6 @@ jobs:
         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:
@@ -63,6 +57,15 @@ jobs:
           username: ${{ github.actor }}
           password: ${{ secrets.GITHUB_TOKEN }}
 
+      - name: Determine base image tag
+        id: base
+        run: |
+          if [ "${{ github.event_name }}" = "pull_request" ]; then
+            echo "tag=pr-${{ github.event.number }}" >> "$GITHUB_OUTPUT"
+          else
+            echo "tag=latest" >> "$GITHUB_OUTPUT"
+          fi
+
       # Build the image
       - name: Build base image
         uses: docker/build-push-action@v4
@@ -70,16 +73,17 @@ jobs:
           context: .
           push: true
           platforms: linux/amd64,linux/arm64
-          tags: ghcr.io/${{ github.repository_owner }}/base:latest
+          tags: ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
+          cache-from: type=gha,scope=buildx-base-multi-arch
+          cache-to: type=gha,scope=buildx-base-multi-arch,mode=max
 
-      # revoltchat/server
+      # stoatchat/api
       - name: Docker meta
         id: meta-delta
         uses: docker/metadata-action@v4
         with:
           images: |
-            docker.io/revoltchat/server
-            ghcr.io/revoltchat/server
+            ghcr.io/stoatchat/api
       - name: Publish
         uses: docker/build-push-action@v4
         with:
@@ -89,17 +93,16 @@ jobs:
           file: crates/delta/Dockerfile
           tags: ${{ steps.meta-delta.outputs.tags }}
           build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
           labels: ${{ steps.meta-delta.outputs.labels }}
 
-      # revoltchat/bonfire
+      # stoatchat/events
       - name: Docker meta
         id: meta-bonfire
         uses: docker/metadata-action@v4
         with:
           images: |
-            docker.io/revoltchat/bonfire
-            ghcr.io/revoltchat/bonfire
+            ghcr.io/stoatchat/events
       - name: Publish
         uses: docker/build-push-action@v4
         with:
@@ -109,17 +112,16 @@ jobs:
           file: crates/bonfire/Dockerfile
           tags: ${{ steps.meta-bonfire.outputs.tags }}
           build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
           labels: ${{ steps.meta-bonfire.outputs.labels }}
 
-      # revoltchat/autumn
+      # stoatchat/file-server
       - name: Docker meta
         id: meta-autumn
         uses: docker/metadata-action@v4
         with:
           images: |
-            docker.io/revoltchat/autumn
-            ghcr.io/revoltchat/autumn
+            ghcr.io/stoatchat/file-server
       - name: Publish
         uses: docker/build-push-action@v4
         with:
@@ -129,17 +131,16 @@ jobs:
           file: crates/services/autumn/Dockerfile
           tags: ${{ steps.meta-autumn.outputs.tags }}
           build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
           labels: ${{ steps.meta-autumn.outputs.labels }}
 
-      # revoltchat/january
+      # stoatchat/proxy
       - name: Docker meta
         id: meta-january
         uses: docker/metadata-action@v4
         with:
           images: |
-            docker.io/revoltchat/january
-            ghcr.io/revoltchat/january
+            ghcr.io/stoatchat/proxy
       - name: Publish
         uses: docker/build-push-action@v4
         with:
@@ -149,17 +150,35 @@ jobs:
           file: crates/services/january/Dockerfile
           tags: ${{ steps.meta-january.outputs.tags }}
           build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
           labels: ${{ steps.meta-january.outputs.labels }}
 
-      # revoltchat/crond
+      # stoatchat/gifbox
+      - name: Docker meta
+        id: meta-gifbox
+        uses: docker/metadata-action@v4
+        with:
+          images: |
+            ghcr.io/stoatchat/gifbox
+      - name: Publish
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          push: true
+          platforms: linux/amd64,linux/arm64
+          file: crates/services/gifbox/Dockerfile
+          tags: ${{ steps.meta-gifbox.outputs.tags }}
+          build-args: |
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
+          labels: ${{ steps.meta-gifbox.outputs.labels }}
+
+      # stoatchat/crond
       - name: Docker meta
         id: meta-crond
         uses: docker/metadata-action@v4
         with:
           images: |
-            docker.io/revoltchat/crond
-            ghcr.io/revoltchat/crond
+            ghcr.io/stoatchat/crond
       - name: Publish
         uses: docker/build-push-action@v4
         with:
@@ -169,17 +188,16 @@ jobs:
           file: crates/daemons/crond/Dockerfile
           tags: ${{ steps.meta-crond.outputs.tags }}
           build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
           labels: ${{ steps.meta-crond.outputs.labels }}
 
-      # revoltchat/pushd
+      # stoatchat/pushd
       - name: Docker meta
         id: meta-pushd
         uses: docker/metadata-action@v4
         with:
           images: |
-            docker.io/revoltchat/pushd
-            ghcr.io/revoltchat/pushd
+            ghcr.io/stoatchat/pushd
       - name: Publish
         uses: docker/build-push-action@v4
         with:
@@ -189,5 +207,24 @@ jobs:
           file: crates/daemons/pushd/Dockerfile
           tags: ${{ steps.meta-pushd.outputs.tags }}
           build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
           labels: ${{ steps.meta-pushd.outputs.labels }}
+
+      # stoatchat/voice-ingress
+      - name: Docker meta
+        id: meta-voice-ingress
+        uses: docker/metadata-action@v4
+        with:
+          images: |
+            ghcr.io/stoatchat/voice-ingress
+      - name: Publish
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          push: true
+          platforms: linux/amd64,linux/arm64
+          file: crates/daemons/voice-ingress/Dockerfile
+          tags: ${{ steps.meta-voice-ingress.outputs.tags }}
+          build-args: |
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:${{ steps.base.outputs.tag }}
+          labels: ${{ steps.meta-voice-ingress.outputs.labels }}

.github/workflows/docs-test.yml

@@ -0,0 +1,23 @@
+name: Documentation (test)
+
+on:
+  pull_request:
+
+jobs:
+  test-deploy:
+    name: Test deployment
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ./docs
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Mise
+        uses: immich-app/devtools/actions/use-mise@cd24790a7f5f6439ac32cc94f5523cb2de8bfa8c # use-mise-action-v1.1.0
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+        
+      - run: mise docs:build

.github/workflows/docs.yml

@@ -0,0 +1,48 @@
+name: Documentation
+
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  build:
+    name: Build Docusaurus
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ./docs
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+
+      - name: Setup Mise
+        uses: immich-app/devtools/actions/use-mise@cd24790a7f5f6439ac32cc94f5523cb2de8bfa8c # use-mise-action-v1.1.0
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+        
+      - run: mise docs:build
+
+      - name: Upload Build Artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: ./docs/build
+
+  deploy:
+    name: Deploy to GitHub Pages
+    needs: build
+
+    permissions:
+      pages: write # to deploy to Pages
+      id-token: write # to verify the deployment originates from an appropriate source
+
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+
+    runs-on: ubuntu-latest
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

.github/workflows/git-town.yml

@@ -0,0 +1,23 @@
+# DO NOT EDIT DIRECTLY IN REPOSITORY
+# Managed in Terraform templates
+
+name: Git Town
+
+on:
+  pull_request:
+
+jobs:
+  git-town:
+    name: Display the branch stack
+    runs-on: ubuntu-slim
+
+    if: ${{ github.event.pull_request.head.repo.full_name == github.repository && !startsWith(github.head_ref, 'release-please--') }}
+
+    permissions:
+      contents: read
+      pull-requests: write
+
+    steps:
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+      - uses: stoatchat/action-git-town@4bc5c942e4603bffa0806b51d5fe5f0bc5deb0ac
+        continue-on-error: true

.github/workflows/publish-crates.yml

@@ -0,0 +1,26 @@
+name: Publish Crates
+
+on:
+  workflow_dispatch:
+  release:
+    types: [published]
+
+jobs:
+  publish:
+    name: Publish Crates
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          persist-credentials: false
+
+      - name: Setup Mise
+        uses: immich-app/devtools/actions/use-mise@cd24790a7f5f6439ac32cc94f5523cb2de8bfa8c # use-mise-action-v1.1.0
+        with:
+          github-token: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Publish
+        env:
+          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
+        run: mise publish --workspace

.github/workflows/release-please.yml

@@ -0,0 +1,63 @@
+name: Release Please
+
+on:
+  push:
+    branches: [main] # updates/opens the release PR when commits land on main
+  workflow_dispatch:
+
+permissions:
+  contents: write
+  pull-requests: write
+  id-token: write
+
+concurrency:
+  group: release-please
+  cancel-in-progress: true
+
+jobs:
+  release-please:
+    name: Release Please
+    runs-on: ubuntu-latest
+    outputs:
+      release_created: ${{ steps.rp.outputs.release_created }}
+      tag_name: ${{ steps.rp.outputs.tag_name }}
+    steps:
+      - id: app-token
+        uses: actions/create-github-app-token@v2
+        with:
+          app-id: ${{ secrets.GH_STOAT_RELEASE_APP_ID }}
+          private-key: ${{ secrets.GH_STOAT_RELEASE_APP_PRIVATE_KEY }}
+      - id: rp
+        uses: googleapis/release-please-action@v4
+        with:
+          token: ${{ steps.app-token.outputs.token }}
+          config-file: release-please-config.json
+
+      - name: Install latest stable
+        uses: dtolnay/rust-toolchain@e97e2d8cc328f1b50210efc529dca0028893a2d9 # v1
+        with:
+          toolchain: stable
+
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        with:
+          token: ${{ steps.app-token.outputs.token }}
+      - name: Update Cargo.lock
+        if: ${{ steps.rp.outputs.prs_created == 'true' || steps.rp.outputs.prs_updated == 'true' }}
+        env:
+          GH_TOKEN: ${{ steps.app-token.outputs.token }}
+          RP_PR_OUTPUT_JSON: ${{ steps.rp.outputs.prs }}
+        run: |
+          PR_NUMBER=$(echo "$RP_PR_OUTPUT_JSON" | jq -r '.[0].number')
+          gh pr checkout "$PR_NUMBER"
+          
+          cargo update -w
+          
+          if git diff --quiet Cargo.lock; then
+            echo "No changes to Cargo.lock"
+          else
+            git config user.name "github-actions[bot]"
+            git config user.email "github-actions[bot]@users.noreply.github.com"
+            git add Cargo.lock
+            git commit -s -m "chore: update Cargo.lock"
+            git push
+          fi

.github/workflows/release-webhook.yml

@@ -0,0 +1,26 @@
+# DO NOT EDIT DIRECTLY IN REPOSITORY
+# Managed in Terraform templates
+
+name: Release Webhook
+
+on:
+  workflow_dispatch:
+  release:
+    types: [published]
+
+jobs:
+  release-webhook:
+    name: Send Release Webhook
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Send release notification webhook
+        env:
+          TAG_NAME: ${{ github.event.release.tag_name }}
+          REPOSITORY: ${{ github.repository }}
+          WEBHOOK_URL: ${{ secrets.STOAT_WEBHOOK_UPDATES_URL }}
+        run: |
+          RELEASE_URL="https://github.com/${REPOSITORY}/releases/tag/${TAG_NAME}"
+          curl -X POST "$WEBHOOK_URL" \
+            -H "Content-Type: application/json" \
+            -d "{\"content\": \"$RELEASE_URL\"}"

.github/workflows/renovate.yml

@@ -0,0 +1,30 @@
+# DO NOT EDIT DIRECTLY IN REPOSITORY
+# Managed in Terraform templates
+
+name: Renovate
+on:
+  workflow_dispatch:
+  schedule:
+    - cron: '0/15 * * * *'
+jobs:
+  renovate:
+    runs-on: ubuntu-latest
+    steps:
+      - id: app-token
+        uses: actions/create-github-app-token@v2
+        with:
+          app-id: ${{ secrets.GH_STOAT_RELEASE_APP_ID }}
+          private-key: ${{ secrets.GH_STOAT_RELEASE_APP_PRIVATE_KEY }}
+
+      - name: Setup Mise
+        uses: immich-app/devtools/actions/use-mise@7b8610a904d57da241e4ddba17fa62b62b15aed4 # use-mise-action-v2.0.2
+        with:
+          github_token: ${{ steps.app-token.outputs.token }}
+
+      - name: Self-hosted Renovate
+        uses: renovatebot/github-action@v46.1.14
+        with:
+          token: '${{ steps.app-token.outputs.token }}'
+        env:
+          RENOVATE_PLATFORM_COMMIT: 'enabled'
+          RENOVATE_REPOSITORIES: '${{ github.repository }}'

.github/workflows/rust.yaml

@@ -2,16 +2,12 @@ name: Rust build, test, and generate specification
 
 on:
   push:
-    paths-ignore:
-      - ".github/**"
-      - "!.github/workflows/rust.yaml"
-      - ".vscode/**"
-      - "doc/**"
-      - ".gitignore"
-      - "LICENSE"
-      - "README"
-  pull_request:
     branches: [main]
+  pull_request:
+
+concurrency:
+  group: ${{ github.head_ref || github.ref }}
+  cancel-in-progress: true
 
 env:
   CARGO_TERM_COLOR: always
@@ -19,63 +15,60 @@ env:
 jobs:
   check:
     name: Rust project
-    runs-on: ubuntu-latest
+    runs-on: arc-runner-set
     steps:
-      - uses: actions/checkout@v2
-      - name: Install latest stable
-        uses: actions-rs/toolchain@v1
+      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
         with:
-          toolchain: stable
-          override: true
-          components: rustfmt, clippy
-      - name: Install cargo-nextest
-        uses: baptiste0928/cargo-install@v1
+          persist-credentials: false
+
+      # Using our own runners for now:
+      # - name: Free up disk space
+      #   run: |
+      #     sudo rm -rf /usr/local/lib/android /usr/share/dotnet /opt/ghc
+
+      - name: Setup Mise
+        uses: immich-app/devtools/actions/use-mise@cd24790a7f5f6439ac32cc94f5523cb2de8bfa8c # use-mise-action-v1.1.0
         with:
-          crate: cargo-nextest
-          locked: true
+          github-token: ${{ secrets.GITHUB_TOKEN }}
 
-      - name: Run cargo build
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-
-      - name: Run services in background
-        run: |
-          docker compose -f compose.yml up -d
-
-      - name: Run cargo test
+      - run: mise build
+      - run: mise docker:start
+    
+      - name: Reference Test
         env:
           TEST_DB: REFERENCE
+        continue-on-error: ${{ github.ref_name == 'main' }}
         run: |
-          cargo nextest run
+          mise test
 
-      - name: Run cargo test (with MongoDB)
+      - name: MongoDB Test
         env:
           TEST_DB: MONGODB
           MONGODB: mongodb://localhost
+        continue-on-error: ${{ github.ref_name == 'main' }}
         run: |
-          cargo nextest run
+          mise test
 
       - name: Start API in background
         if: github.event_name != 'pull_request' && github.ref_name == 'main'
         env:
           TEST_DB: REFERENCE
         run: |
-          cargo build --bin revolt-delta && (cargo run --bin revolt-delta &)
+          mise build --bin revolt-delta && (mise service:api &)
 
       - name: Wait for API to go up
         if: github.event_name != 'pull_request' && github.ref_name == 'main'
-        uses: nev7n/wait_for_response@v1
+        uses: nev7n/wait_for_response@7fef3c1a6e8939d0b09062f14fec50d3c5d15fa1 # v1.0.1
         with:
           url: "http://localhost:14702/"
 
       - name: Checkout API repository
         if: github.event_name != 'pull_request' && github.ref_name == 'main'
-        uses: actions/checkout@v3
+        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
         with:
-          repository: revoltchat/api
+          repository: stoatchat/javascript-client-api
           path: api
-          token: ${{ secrets.PAT }}
+          ssh-key: ${{ secrets.DEPLOY_KEY_JAVASCRIPT_CLIENT_API }}
 
       - name: Download OpenAPI specification
         if: github.event_name != 'pull_request' && github.ref_name == 'main'
@@ -83,10 +76,10 @@ jobs:
 
       - name: Commit changes
         if: github.event_name != 'pull_request' && github.ref_name == 'main'
-        uses: EndBug/add-and-commit@v4
+        uses: EndBug/add-and-commit@a94899bca583c204427a224a7af87c02f9b325d5 # v9.1.4
         with:
           cwd: "api"
           add: "*.json"
-          author_name: Revolt CI
-          author_email: revolt-ci@users.noreply.github.com
+          author_name: Stoat CI
+          author_email: stoat-ci@users.noreply.github.com
           message: "chore: generate OpenAPI specification"

.github/workflows/triage_issue.yml

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

.github/workflows/triage_pr.yml

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

.github/workflows/validate-pr-title.yml

@@ -0,0 +1,23 @@
+# DO NOT EDIT DIRECTLY IN REPOSITORY
+# Managed in Terraform templates
+
+name: "Lint PR"
+
+on:
+  pull_request_target:
+    types:
+      - opened
+      - reopened
+      - edited
+      - synchronize
+
+jobs:
+  main:
+    name: Validate PR title
+    runs-on: ubuntu-latest
+    permissions:
+      pull-requests: read
+    steps:
+      - uses: amannn/action-semantic-pull-request@48f256284bd46cdaab1048c3721360e808335d50 # v6.1.1
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -11,4 +11,5 @@ venv/
 .vercel
 .DS_Store
 
+livekit.yml
 .idea

.mise/config.toml

@@ -0,0 +1,28 @@
+[tools]
+node = "25.4.0"
+pnpm = "10.28.1"
+
+gh = "2.25.0"
+
+rust = "1.92.0"
+"cargo:cargo-nextest" = "0.9.122"
+
+"github:git-town/git-town" = "22.4.0"
+
+[settings]
+experimental = true
+idiomatic_version_file_enable_tools = ["rust"]
+
+[tasks.start]
+description = "Run all services"
+depends = ["docker:start", "build"]
+wait_for = ["docker:start", "build"]
+run = [{ task = "service:*" }]
+
+[env]
+BUILDER = "cargo"
+DOCKER_NETWORK_NAME = "stoatchat_default"
+DATABASE_PORT = "27017"
+RABBIT_PORT = "5672"
+REDIS_PORT = "6379"
+_.file = { path = ".env", tools = true }

.mise/tasks/build

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+#MISE description="Build project"
+set -e
+
+${BUILDER} build "$@"

.mise/tasks/check

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+#MISE description="Check project with clippy"
+set -e
+
+cargo clippy

.mise/tasks/docker/start

@@ -0,0 +1,13 @@
+#!/usr/bin/env bash
+#MISE description="Start Docker containers"
+set -e
+
+docker compose up -d
+
+docker run \
+--network=${DOCKER_NETWORK_NAME} \
+--name wait \
+--rm dokku/wait  -c \
+rabbit:${RABBIT_PORT},\
+database:${DATABASE_PORT},\
+redis:${REDIS_PORT}

.mise/tasks/docker/stop

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+#MISE description="Stop Docker containers"
+set -e
+
+docker compose down

.mise/tasks/docs/_default

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+#MISE description="Start the Stoat Developers website"
+#MISE depends=["docs:install"]
+#MISE dir="{{config_root}}/docs"
+set -e
+
+pnpm build

.mise/tasks/docs/build

@@ -0,0 +1,7 @@
+#!/usr/bin/env bash
+#MISE description="Build the Stoat Developers website"
+#MISE depends=["docs:install"]
+#MISE dir="{{config_root}}/docs"
+set -e
+
+pnpm build

.mise/tasks/docs/install

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+#MISE description="Install dependencies for docs site"
+#MISE dir="{{config_root}}/docs"
+set -e
+
+pnpm i --frozen-lockfile

.mise/tasks/publish

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+#MISE description="Publish project"
+set -e
+
+cargo publish "$@"

.mise/tasks/service/api

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+#MISE description="Run API server"
+set -e
+
+cargo run --bin revolt-delta

.mise/tasks/service/crond

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+#MISE description="Run cron daemon"
+set -e
+
+cargo run --bin revolt-crond

.mise/tasks/service/events

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+#MISE description="Run events server"
+set -e
+
+cargo run --bin revolt-bonfire

.mise/tasks/service/files

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+#MISE description="Run file server"
+set -e
+
+cargo run --bin revolt-autumn

.mise/tasks/service/gifbox

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+#MISE description="Run GIF proxy server"
+set -e
+
+cargo run --bin revolt-gifbox

.mise/tasks/service/proxy

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+#MISE description="Run proxy server"
+set -e
+
+cargo run --bin revolt-january

.mise/tasks/service/pushd

@@ -0,0 +1,5 @@
+#!/usr/bin/env bash
+#MISE description="Run push daemon"
+set -e
+
+cargo run --bin revolt-pushd

.mise/tasks/test

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+#MISE description="Test project"
+set -e
+
+: "${TEST_DB:=REFERENCE}"
+export TEST_DB
+
+cargo nextest run

.release-please-manifest.json

@@ -0,0 +1,3 @@
+{
+    ".": "0.13.7"
+}

CHANGELOG.md

@@ -0,0 +1,288 @@
+# Changelog
+
+## [0.13.7](https://github.com/stoatchat/stoatchat/compare/v0.13.6...v0.13.7) (2026-05-21)
+
+
+### Bug Fixes
+
+* sanitize emoji input to handle variation selectors ([#774](https://github.com/stoatchat/stoatchat/issues/774)) ([2d308e0](https://github.com/stoatchat/stoatchat/commit/2d308e03d58c19f27b5b4d65dc2a15ef20b56190))
+* update mention count badge for channel acks ([#769](https://github.com/stoatchat/stoatchat/issues/769)) ([0d9ae50](https://github.com/stoatchat/stoatchat/commit/0d9ae508d9d2199f0e408b8ca634d20489be6f61))
+
+## [0.13.6](https://github.com/stoatchat/stoatchat/compare/v0.13.5...v0.13.6) (2026-05-18)
+
+
+### Features
+
+* Update FCM payload for android notifications ([#766](https://github.com/stoatchat/stoatchat/issues/766)) ([acbc087](https://github.com/stoatchat/stoatchat/commit/acbc087982e9aeb05cabc5ab4c9b1291f67490ad))
+* user slowmode events ([#760](https://github.com/stoatchat/stoatchat/issues/760)) ([af0d8aa](https://github.com/stoatchat/stoatchat/commit/af0d8aad14dc68d88159d0e1c714077d362e21e4))
+
+
+### Bug Fixes
+
+* include `minio` region as tests need it ([#761](https://github.com/stoatchat/stoatchat/issues/761)) ([298742d](https://github.com/stoatchat/stoatchat/commit/298742dbad4eafae356f976c56b9db23904b0c3a))
+* set env var for publishing crates ([#768](https://github.com/stoatchat/stoatchat/issues/768)) ([018afaf](https://github.com/stoatchat/stoatchat/commit/018afaf38f6330d92dad2a68b640c0cb3f6b639a))
+* Use proper headers to determine IP when not behind cloudflare ([#764](https://github.com/stoatchat/stoatchat/issues/764)) ([494c8b7](https://github.com/stoatchat/stoatchat/commit/494c8b7cabaae2a51039a7a5b559d5e2e5279554))
+* voice ingress crashing due to new Result in AMQP::new_auto() ([#765](https://github.com/stoatchat/stoatchat/issues/765)) ([2871632](https://github.com/stoatchat/stoatchat/commit/2871632382395cb20cbe0047c542d3ac31ff3f03))
+
+
+### Miscellaneous Chores
+
+* switch to lapin ([#767](https://github.com/stoatchat/stoatchat/issues/767)) ([5b19853](https://github.com/stoatchat/stoatchat/commit/5b1985381ae829a92c80a19e91a414cd9dc4de93))
+
+## [0.13.5](https://github.com/stoatchat/stoatchat/compare/v0.13.4...v0.13.5) (2026-05-17)
+
+
+### Bug Fixes
+
+* dont panic on hash missing when deleting files ([#755](https://github.com/stoatchat/stoatchat/issues/755)) ([c902077](https://github.com/stoatchat/stoatchat/commit/c902077cf51076fee11712eb732dc8a8f786fc4b))
+
+## [0.13.4](https://github.com/stoatchat/stoatchat/compare/v0.13.3...v0.13.4) (2026-05-16)
+
+
+### Bug Fixes
+
+* add TLS feature to livekit-api crate ([#753](https://github.com/stoatchat/stoatchat/issues/753)) ([6cfee1f](https://github.com/stoatchat/stoatchat/commit/6cfee1f601c1e084df7c8f1e7a5e8a560d1dd514))
+
+## [0.13.3](https://github.com/stoatchat/stoatchat/compare/v0.13.2...v0.13.3) (2026-05-15)
+
+
+### Bug Fixes
+
+* don't automatically set up rabbitmq in delta ([#749](https://github.com/stoatchat/stoatchat/issues/749)) ([7647cfc](https://github.com/stoatchat/stoatchat/commit/7647cfc8d93aba99f5faef13eb3d970097540d76))
+* don't declare queues which seem to cause the backend to crash in prod ([7647cfc](https://github.com/stoatchat/stoatchat/commit/7647cfc8d93aba99f5faef13eb3d970097540d76))
+
+## [0.13.2](https://github.com/stoatchat/stoatchat/compare/v0.13.1...v0.13.2) (2026-05-11)
+
+
+### Bug Fixes
+
+* update default exchange to `revolt.default` ([#746](https://github.com/stoatchat/stoatchat/issues/746)) ([fcb8091](https://github.com/stoatchat/stoatchat/commit/fcb8091cd7a00d7f26c798daa33aae4b923b2a8b))
+
+## [0.13.1](https://github.com/stoatchat/stoatchat/compare/v0.13.0...v0.13.1) (2026-05-10)
+
+
+### Bug Fixes
+
+* amqprs startup bug ([#744](https://github.com/stoatchat/stoatchat/issues/744)) ([1100eaf](https://github.com/stoatchat/stoatchat/commit/1100eaf46f849f2509ae01ac497556ca33bde778))
+
+## [0.13.0](https://github.com/stoatchat/stoatchat/compare/v0.12.1...v0.13.0) (2026-05-08)
+
+
+### Features
+
+* add embed support for YouTube Shorts ([#734](https://github.com/stoatchat/stoatchat/issues/734)) ([d46c7f7](https://github.com/stoatchat/stoatchat/commit/d46c7f7f3c04524c0639c3e0a122626f8e0b3bf7))
+* add emoji rename endpoint ([#714](https://github.com/stoatchat/stoatchat/issues/714)) ([23ad135](https://github.com/stoatchat/stoatchat/commit/23ad1359834bb7d07a460b8678d6a6ebffc73eb0))
+* add legal links to root payload ([#733](https://github.com/stoatchat/stoatchat/issues/733)) ([21d8201](https://github.com/stoatchat/stoatchat/commit/21d82018cf84ab0fdd10613d254b9562aea8eea3))
+* add role icon support ([#724](https://github.com/stoatchat/stoatchat/issues/724)) ([841985d](https://github.com/stoatchat/stoatchat/commit/841985d3b994df1c6eefab2fc7ecbd77ab22c493))
+* Add webhook endpoints for editing and deleting messages ([#682](https://github.com/stoatchat/stoatchat/issues/682)) ([6f3441c](https://github.com/stoatchat/stoatchat/commit/6f3441cf4acac2a8e6e1bf07a279a153b80f7956))
+* automatically sanitise usernames on create/update ([#689](https://github.com/stoatchat/stoatchat/issues/689)) ([e937697](https://github.com/stoatchat/stoatchat/commit/e93769786c7669485a659ee471630740d3cea702))
+* blacklist private ip ranges and add january domain blocklist ([#731](https://github.com/stoatchat/stoatchat/issues/731)) ([6b41db9](https://github.com/stoatchat/stoatchat/commit/6b41db984bb491b2e58324309cc70d8c14e0b814))
+* Rewrite acks ([#741](https://github.com/stoatchat/stoatchat/issues/741)) ([ab5bd47](https://github.com/stoatchat/stoatchat/commit/ab5bd47a39ee889de0b5ae6e7b560620853daead))
+
+
+### Bug Fixes
+
+* add new_user_hours to configuration limits ([#729](https://github.com/stoatchat/stoatchat/issues/729)) ([279f5d5](https://github.com/stoatchat/stoatchat/commit/279f5d5fd7af2df55902c706859ec07f569cdb1e))
+* add reconnection policy to Redis subscriber to prevent ghost state ([#708](https://github.com/stoatchat/stoatchat/issues/708)) ([057f2bb](https://github.com/stoatchat/stoatchat/commit/057f2bb8b359f8b942741a30ff54eeb8fbe3e0b1))
+* docker compose file had personal url in it ([#742](https://github.com/stoatchat/stoatchat/issues/742)) ([0719985](https://github.com/stoatchat/stoatchat/commit/0719985ac5636590f91e6f9ec4b68f3eded70c13))
+* don't strip ICC from exif ([#735](https://github.com/stoatchat/stoatchat/issues/735)) ([d76a711](https://github.com/stoatchat/stoatchat/commit/d76a71141f3e508f6308ba52fa28eaeb56fb3438))
+* dont send notification in fcm ([#721](https://github.com/stoatchat/stoatchat/issues/721)) ([89171e9](https://github.com/stoatchat/stoatchat/commit/89171e9bd0f15711157e78c6eec0fe7b480de93a))
+* encode filenames in redirects ([#737](https://github.com/stoatchat/stoatchat/issues/737)) ([9fd7128](https://github.com/stoatchat/stoatchat/commit/9fd7128f800badbd184baf943d4f799e601201e4))
+* january ip redirects & domain resolver ([#738](https://github.com/stoatchat/stoatchat/issues/738)) ([356491e](https://github.com/stoatchat/stoatchat/commit/356491e934b274f9e895df883dd63ef0b3123510))
+* update message length validation to remove upper limit ([#723](https://github.com/stoatchat/stoatchat/issues/723)) ([ed4fd5e](https://github.com/stoatchat/stoatchat/commit/ed4fd5ebfe6d0ea534a0898da4afdc1f4e2cd6c5))
+* use correct response for NoEffect errors ([#732](https://github.com/stoatchat/stoatchat/issues/732)) ([5378cd2](https://github.com/stoatchat/stoatchat/commit/5378cd22b4c7d85f44c31a6af0dda00941b80d5c))
+
+## [0.12.1](https://github.com/stoatchat/stoatchat/compare/v0.12.0...v0.12.1) (2026-04-10)
+
+
+### Bug Fixes
+
+* add migration to update existing files to be animated ([#705](https://github.com/stoatchat/stoatchat/issues/705)) ([f2c056a](https://github.com/stoatchat/stoatchat/commit/f2c056a1515be493b195f3f5db5886c2ddf36700))
+* don't send self dm notifications ([#706](https://github.com/stoatchat/stoatchat/issues/706)) ([f30b729](https://github.com/stoatchat/stoatchat/commit/f30b729ca90d0be6853c57ab4935694e5e59ae56))
+* mise start + missing docker image ([#564](https://github.com/stoatchat/stoatchat/issues/564)) ([fb8fe16](https://github.com/stoatchat/stoatchat/commit/fb8fe1655776791421284a6a093e86f0320c258a))
+* test failure due to wrong assertion ([#707](https://github.com/stoatchat/stoatchat/issues/707)) ([f81e329](https://github.com/stoatchat/stoatchat/commit/f81e3291bdd57af9ceedb2987b111acc7051d69c))
+
+## [0.12.0](https://github.com/stoatchat/stoatchat/compare/v0.11.5...v0.12.0) (2026-03-28)
+
+
+### Features
+
+* add bug report template for issue tracking ([#627](https://github.com/stoatchat/stoatchat/issues/627)) ([f777e28](https://github.com/stoatchat/stoatchat/commit/f777e2863c6ca50057c8b5d0a5be14915d287724))
+* Add slowmode functionality to text channels ([#680](https://github.com/stoatchat/stoatchat/issues/680)) ([6107f24](https://github.com/stoatchat/stoatchat/commit/6107f242fd3ebaff71a15f9a16330ffbcb4f2d7b))
+* Allow restricting server creation to specific users ([#685](https://github.com/stoatchat/stoatchat/issues/685)) ([edfa97d](https://github.com/stoatchat/stoatchat/commit/edfa97db108c9c81828547f98a1db5315cb5ba4a))
+* compute thumbhash for images ([#596](https://github.com/stoatchat/stoatchat/issues/596)) ([c2d4369](https://github.com/stoatchat/stoatchat/commit/c2d4369e160f32d79bce0a0b0f14677f89de3669))
+* Detect animation in image files for fetch_preview ([#574](https://github.com/stoatchat/stoatchat/issues/574)) ([3fa0abf](https://github.com/stoatchat/stoatchat/commit/3fa0abf47f5f42ddd8ee041fe4c44fbc5ba800c1))
+* expose global and user limits in root API response ([#644](https://github.com/stoatchat/stoatchat/issues/644)) ([0b522eb](https://github.com/stoatchat/stoatchat/commit/0b522ebddc17f2e3f792ff5e2347793e9849fa23))
+* implement time based message sweep on user ban ([#670](https://github.com/stoatchat/stoatchat/issues/670)) ([98c7b1b](https://github.com/stoatchat/stoatchat/commit/98c7b1b5a5b9fdac5c0ab83be10f0e23114dbfc9))
+* load config from env vars ([#576](https://github.com/stoatchat/stoatchat/issues/576)) ([5191bd1](https://github.com/stoatchat/stoatchat/commit/5191bd16b2a905b8409838e34eb0baca96f08580))
+* parse message push notification content and replace internal formatting ([#693](https://github.com/stoatchat/stoatchat/issues/693)) ([d1e72ce](https://github.com/stoatchat/stoatchat/commit/d1e72cee42c54e16f4e49af569897528b10a28ca))
+* Transfer ownership ([#396](https://github.com/stoatchat/stoatchat/issues/396)) ([735d644](https://github.com/stoatchat/stoatchat/commit/735d644e043793cb86e74aab5b88bb4b8bc17ba2))
+* update livekit ([#698](https://github.com/stoatchat/stoatchat/issues/698)) ([f181edc](https://github.com/stoatchat/stoatchat/commit/f181edc8f2ff3ce4b6d48938dfc73931ecfa2279))
+
+
+### Bug Fixes
+
+* add flag for disabling events instead of commenting them out ([#695](https://github.com/stoatchat/stoatchat/issues/695)) ([a5cd08a](https://github.com/stoatchat/stoatchat/commit/a5cd08a655dece4269f3ac84fa2387ae356709a5))
+* add masquerade permission to default direct message settings ([#665](https://github.com/stoatchat/stoatchat/issues/665)) ([ab52569](https://github.com/stoatchat/stoatchat/commit/ab525699bd6663333f0e9fed6d2455e482e6a09f))
+* Check for appropriate permission for removing other users avatar ([#657](https://github.com/stoatchat/stoatchat/issues/657)) ([d56135e](https://github.com/stoatchat/stoatchat/commit/d56135e0cbc713884c9378832952f7ad490fa315))
+* default video resolution is a non-existent size ([#601](https://github.com/stoatchat/stoatchat/issues/601)) ([0698e11](https://github.com/stoatchat/stoatchat/commit/0698e115e8d003d615e468c4fb9654e6bbc9107f)), closes [#588](https://github.com/stoatchat/stoatchat/issues/588)
+* **docs:** Update GitHub links ([#647](https://github.com/stoatchat/stoatchat/issues/647)) ([b830631](https://github.com/stoatchat/stoatchat/commit/b830631bd25a546844b7bdd30386084bb365e4de))
+* don't use a bitop for OR ([#676](https://github.com/stoatchat/stoatchat/issues/676)) ([5701b5c](https://github.com/stoatchat/stoatchat/commit/5701b5c18c513f796af365169ceaea372a22638c))
+* Fix typo for p256dh in vapid notification flow ([#622](https://github.com/stoatchat/stoatchat/issues/622)) ([a80ad1c](https://github.com/stoatchat/stoatchat/commit/a80ad1cbe58b8af5e45751e51d94d93c1cea1c9f))
+* improve generated openapi.json ([#584](https://github.com/stoatchat/stoatchat/issues/584)) ([52ed510](https://github.com/stoatchat/stoatchat/commit/52ed5100c2446e0b261085639e123e7e124cab2c))
+* no node state set on channel creation ([#653](https://github.com/stoatchat/stoatchat/issues/653)) ([24d0d2b](https://github.com/stoatchat/stoatchat/commit/24d0d2b7266f6f8a692d0a52704acfecf517674c))
+* only show first line on commit messages ([#696](https://github.com/stoatchat/stoatchat/issues/696)) ([91783b9](https://github.com/stoatchat/stoatchat/commit/91783b906697fc85305dee683f7c15dda55f0c50))
+* pass &str to Reference ([#697](https://github.com/stoatchat/stoatchat/issues/697)) ([ccda6f5](https://github.com/stoatchat/stoatchat/commit/ccda6f5c53ee043705f7ff6b5f6c393f020781de))
+* redis_url vs redis_uri in config ([#666](https://github.com/stoatchat/stoatchat/issues/666)) ([b0b728f](https://github.com/stoatchat/stoatchat/commit/b0b728fb0dbc9ee28360301de1c3ea501bbbff1d))
+* replace some links and Revolt mentions to current Stoat ([#515](https://github.com/stoatchat/stoatchat/issues/515)) ([d629e89](https://github.com/stoatchat/stoatchat/commit/d629e89304be2f0011e189293b278f07d346aa7d))
+* send push notifications for DM and group messages ([#660](https://github.com/stoatchat/stoatchat/issues/660)) ([52c0d2f](https://github.com/stoatchat/stoatchat/commit/52c0d2f266b76d8975bba2d5e75c62bb30149c45))
+* store server id in redis and in room metadata to be able to delete voice state in all scenarios ([#656](https://github.com/stoatchat/stoatchat/issues/656)) ([49c6289](https://github.com/stoatchat/stoatchat/commit/49c628958070e4f0a5edc764d3b48158589219d9))
+* uname is missing from crond ([#675](https://github.com/stoatchat/stoatchat/issues/675)) ([dc4438b](https://github.com/stoatchat/stoatchat/commit/dc4438bc3c7b2cad8d442b3cd438afb9ed566a5e))
+
+## [0.11.5](https://github.com/stoatchat/stoatchat/compare/v0.11.4...v0.11.5) (2026-02-17)
+
+
+### Reverts
+
+* disable user update events ([#593](https://github.com/stoatchat/stoatchat/issues/593)) ([1c98ead](https://github.com/stoatchat/stoatchat/commit/1c98ead69579b4700be0b51c9020bb8402336cc6))
+
+## [0.11.4](https://github.com/stoatchat/stoatchat/compare/v0.11.3...v0.11.4) (2026-02-16)
+
+
+### Bug Fixes
+
+* add separate config option for redis events replica url ([#590](https://github.com/stoatchat/stoatchat/issues/590)) ([a75e4ea](https://github.com/stoatchat/stoatchat/commit/a75e4eabfc4b34aba7620c82ba77558a32d9e10a))
+
+## [0.11.3](https://github.com/stoatchat/stoatchat/compare/v0.11.2...v0.11.3) (2026-02-13)
+
+
+### Bug Fixes
+
+* cut presence traffic too while we engineer a new events architecture ([#561](https://github.com/stoatchat/stoatchat/issues/561)) ([1f8ea96](https://github.com/stoatchat/stoatchat/commit/1f8ea963ad742f693f405e6438f1c343c81e6579))
+
+## [0.11.2](https://github.com/stoatchat/stoatchat/compare/v0.11.1...v0.11.2) (2026-02-13)
+
+
+### Bug Fixes
+
+* cut events traffic while we engineer a new events architecture ([#559](https://github.com/stoatchat/stoatchat/issues/559)) ([a11986b](https://github.com/stoatchat/stoatchat/commit/a11986ba1ad16b672ff1080913a684567d88adbb))
+
+## [0.11.1](https://github.com/stoatchat/stoatchat/compare/v0.11.0...v0.11.1) (2026-02-13)
+
+
+### Bug Fixes
+
+* bots in multiple voice channel logic ([#544](https://github.com/stoatchat/stoatchat/issues/544)) ([94cb916](https://github.com/stoatchat/stoatchat/commit/94cb916231b9b8befb2e94065917ff40815bec52))
+
+## [0.11.0](https://github.com/stoatchat/stoatchat/compare/v0.10.3...v0.11.0) (2026-02-10)
+
+
+### Features
+
+* appeal to the almighty Spamhaus ([#524](https://github.com/stoatchat/stoatchat/issues/524)) ([5132270](https://github.com/stoatchat/stoatchat/commit/5132270f2edd6df25ce414daa42ed1b2aa6fa7a9))
+
+## [0.10.3](https://github.com/stoatchat/stoatchat/compare/v0.10.2...v0.10.3) (2026-02-07)
+
+
+### Bug Fixes
+
+* update `Revolt` -> `Stoat` in email titles/desc. ([#508](https://github.com/stoatchat/stoatchat/issues/508)) ([84483ce](https://github.com/stoatchat/stoatchat/commit/84483cee7af3e5dfa16f7fe13e334c4d9f5abd60))
+
+## [0.10.2](https://github.com/stoatchat/stoatchat/compare/v0.10.1...v0.10.2) (2026-01-25)
+
+
+### Bug Fixes
+
+* thumbnailification requires rgb8/rgba8 ([#505](https://github.com/stoatchat/stoatchat/issues/505)) ([413aa04](https://github.com/stoatchat/stoatchat/commit/413aa04dcaf8bff3935ed1e5f31432e11a03ce6f))
+
+## [0.10.1](https://github.com/stoatchat/stoatchat/compare/v0.10.0...v0.10.1) (2026-01-25)
+
+
+### Bug Fixes
+
+* use Rust 1.92.0 for Docker build ([#503](https://github.com/stoatchat/stoatchat/issues/503)) ([98da8a2](https://github.com/stoatchat/stoatchat/commit/98da8a28a0aa2fee4e8eee1d86bd7c49e3187477))
+
+## [0.10.0](https://github.com/stoatchat/stoatchat/compare/v0.9.4...v0.10.0) (2026-01-25)
+
+
+### Features
+
+* allow kicking members from voice channels ([#495](https://github.com/stoatchat/stoatchat/issues/495)) ([0dc5442](https://github.com/stoatchat/stoatchat/commit/0dc544249825a49c793309edee5ec1838458a6da))
+* repository architecture for files crate w. added tests ([#498](https://github.com/stoatchat/stoatchat/issues/498)) ([01ded20](https://github.com/stoatchat/stoatchat/commit/01ded209c62208fc906d6aab9b08c04e860e10ef))
+
+
+### Bug Fixes
+
+* expose ratelimit headers via cors ([#496](https://github.com/stoatchat/stoatchat/issues/496)) ([a1a2125](https://github.com/stoatchat/stoatchat/commit/a1a21252d0ad58937e41f16e5fb86f96bebd2a51))
+
+## [0.9.4](https://github.com/stoatchat/stoatchat/compare/v0.9.3...v0.9.4) (2026-01-10)
+
+
+### Bug Fixes
+
+* checkout repo. before bumping lock ([#490](https://github.com/stoatchat/stoatchat/issues/490)) ([b2da2a8](https://github.com/stoatchat/stoatchat/commit/b2da2a858787853be43136fd526a0bd72baf78ef))
+* persist credentials for git repo ([#492](https://github.com/stoatchat/stoatchat/issues/492)) ([c674a9f](https://github.com/stoatchat/stoatchat/commit/c674a9fd4e0abbd51569870e4b38074d4a1de03c))
+
+## [0.9.3](https://github.com/stoatchat/stoatchat/compare/v0.9.2...v0.9.3) (2026-01-10)
+
+
+### Bug Fixes
+
+* pipeline fixes ([#487](https://github.com/stoatchat/stoatchat/issues/487)) ([aeeafeb](https://github.com/stoatchat/stoatchat/commit/aeeafebefc36a43a656cf797c9251ca50292733c))
+
+## [0.9.2](https://github.com/stoatchat/stoatchat/compare/v0.9.1...v0.9.2) (2026-01-10)
+
+
+### Bug Fixes
+
+* disable publish for services ([#485](https://github.com/stoatchat/stoatchat/issues/485)) ([d13609c](https://github.com/stoatchat/stoatchat/commit/d13609c37279d6a40445dcd99564e5c3dd03bac1))
+
+## [0.9.1](https://github.com/stoatchat/stoatchat/compare/v0.9.0...v0.9.1) (2026-01-10)
+
+
+### Bug Fixes
+
+* **ci:** pipeline fixes (marked as fix to force release) ([#483](https://github.com/stoatchat/stoatchat/issues/483)) ([303e52b](https://github.com/stoatchat/stoatchat/commit/303e52b476585eea81c33837f1b01506ce387684))
+
+## [0.9.0](https://github.com/stoatchat/stoatchat/compare/v0.8.8...v0.9.0) (2026-01-10)
+
+
+### Features
+
+* add id field to role ([#470](https://github.com/stoatchat/stoatchat/issues/470)) ([2afea56](https://github.com/stoatchat/stoatchat/commit/2afea56e56017f02de98e67316b4457568ad5b26))
+* add ratelimits to gifbox ([1542047](https://github.com/stoatchat/stoatchat/commit/154204742d21cbeff6e2577b00f50b495ea44631))
+* include groups and dms in fetch mutuals ([caa8607](https://github.com/stoatchat/stoatchat/commit/caa86074680d46223cebc20f41e9c91c41ec825d))
+* include member payload in ServerMemberJoin event ([480f210](https://github.com/stoatchat/stoatchat/commit/480f210ce85271e13d1dac58a5dae08de108579d))
+* initial work on tenor gif searching ([b0c977b](https://github.com/stoatchat/stoatchat/commit/b0c977b324b8144c1152589546eb8fec5954c3e7))
+* make message lexer use unowned string ([1561481](https://github.com/stoatchat/stoatchat/commit/1561481eb4cdc0f385fbf0a81e4950408050e11f))
+* ready payload field customisation ([db57706](https://github.com/stoatchat/stoatchat/commit/db577067948f13e830b5fb773034e9713a1abaff))
+* require auth for search ([b5cd5e3](https://github.com/stoatchat/stoatchat/commit/b5cd5e30ef7d5e56e8964fb7c543965fa6bf5a4a))
+* trending and categories routes ([5885e06](https://github.com/stoatchat/stoatchat/commit/5885e067a627b8fff1c8ce2bf9e852ff8cf3f07a))
+* voice chats v2 ([#414](https://github.com/stoatchat/stoatchat/issues/414)) ([d567155](https://github.com/stoatchat/stoatchat/commit/d567155f124e4da74115b1a8f810062f7c6559d9))
+
+
+### Bug Fixes
+
+* add license to revolt-parser ([5335124](https://github.com/stoatchat/stoatchat/commit/53351243064cac8d499dd74284be73928fa78a43))
+* allow for disabling default features ([65fbd36](https://github.com/stoatchat/stoatchat/commit/65fbd3662462aed1333b79e59155fa6377e83fcc))
+* apple music to use original url instead of metadata url ([bfe4018](https://github.com/stoatchat/stoatchat/commit/bfe4018e436a4075bae780dd4d35a9b58315e12f))
+* apply uname fix to january and autumn ([8f9015a](https://github.com/stoatchat/stoatchat/commit/8f9015a6ff181d208d9269ab8691bd417d39811a))
+* **ci:** publish images under stoatchat and remove docker hub ([d65c1a1](https://github.com/stoatchat/stoatchat/commit/d65c1a1ab3bdc7e5684b03f280af77d881661a3d))
+* correct miniz_oxide in lockfile ([#478](https://github.com/stoatchat/stoatchat/issues/478)) ([5d27a91](https://github.com/stoatchat/stoatchat/commit/5d27a91e901dd2ea3e860aeaed8468db6c5f3214))
+* correct shebang for try-tag-and-release ([050ba16](https://github.com/stoatchat/stoatchat/commit/050ba16d4adad5d0fb247867aa3e94e3d42bd12d))
+* correct string_cache in lockfile ([#479](https://github.com/stoatchat/stoatchat/issues/479)) ([0b178fc](https://github.com/stoatchat/stoatchat/commit/0b178fc791583064bf9ca94b1d39b42d021e1d79))
+* don't remove timeouts when a member leaves a server ([#409](https://github.com/stoatchat/stoatchat/issues/409)) ([e635bc2](https://github.com/stoatchat/stoatchat/commit/e635bc23ec857d648d5705e1a3875d7bc3402b0d))
+* don't update the same field while trying to remove it ([f4ee35f](https://github.com/stoatchat/stoatchat/commit/f4ee35fb093ca49f0a64ff4b17fd61587df28145)), closes [#392](https://github.com/stoatchat/stoatchat/issues/392)
+* github webhook incorrect payload and formatting ([#468](https://github.com/stoatchat/stoatchat/issues/468)) ([dc9c82a](https://github.com/stoatchat/stoatchat/commit/dc9c82aa4e9667ea6639256c65ac8de37a24d1f7))
+* implement Serialize to ClientMessage ([dea0f67](https://github.com/stoatchat/stoatchat/commit/dea0f675dde7a63c7a59b38d469f878b7a8a3af4))
+* newly created roles should be ranked the lowest ([947eb15](https://github.com/stoatchat/stoatchat/commit/947eb15771ed6785b3dcd16c354c03ded5e4cbe0))
+* permit empty `remove` array in edit requests ([6ad3da5](https://github.com/stoatchat/stoatchat/commit/6ad3da5f35f989a2e7d8e29718b98374248e76af))
+* preserve order of replies in message ([#447](https://github.com/stoatchat/stoatchat/issues/447)) ([657a3f0](https://github.com/stoatchat/stoatchat/commit/657a3f08e5d652814bbf0647e089ed9ebb139bbf))
+* prevent timing out members which have TimeoutMembers permission ([e36fc97](https://github.com/stoatchat/stoatchat/commit/e36fc9738bac0de4f3fcbccba521f1e3754f7ae7))
+* relax settings name regex ([3a34159](https://github.com/stoatchat/stoatchat/commit/3a3415915f0d0fdce1499d47a2b7fa097f5946ea))
+* remove authentication tag bytes from attachment download ([32e6600](https://github.com/stoatchat/stoatchat/commit/32e6600272b885c595c094f0bc69459250220dcb))
+* rename openapi operation ids ([6048587](https://github.com/stoatchat/stoatchat/commit/6048587d348fbca0dc3a9b47690c56df8fece576)), closes [#406](https://github.com/stoatchat/stoatchat/issues/406)
+* respond with 201 if no body in requests ([#465](https://github.com/stoatchat/stoatchat/issues/465)) ([24fedf8](https://github.com/stoatchat/stoatchat/commit/24fedf8c4d9cd3160bdec97aa451520f8beaa739))
+* swap to using reqwest for query building ([38dd4d1](https://github.com/stoatchat/stoatchat/commit/38dd4d10797b3e6e397fc219e818f379bdff19f2))
+* use `trust_cloudflare` config value instead of env var ([cc7a796](https://github.com/stoatchat/stoatchat/commit/cc7a7962a882e1627fcd0bc75858a017415e8cfc))
+* use our own result types instead of tenors types ([a92152d](https://github.com/stoatchat/stoatchat/commit/a92152d86da136997817e797c7af8e38731cdde8))

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace]
-resolver = "2"
+resolver = "3"
 
 members = [
     "crates/delta",
@@ -14,9 +14,192 @@ redis23 = { package = "redis", version = "0.23.3", git = "https://github.com/rev
 #authifier = { package = "authifier", version = "1.0.10", path = "../authifier/crates/authifier" }
 #rocket_authifier = { package = "rocket_authifier", version = "1.0.10", path = "../authifier/crates/rocket_authifier" }
 
-# I'm 99% sure this is overloading the GitHub worker
-# hence builds have been failing since, let's just
-# disable it for now. In the future, we could use this
-# if we were rolling our own CI (that is now).
 [profile.release]
 lto = true
+
+[workspace.dependencies]
+# Async
+async-trait = "0.1.89"
+tokio = "1.49.0"
+async-channel = "2.3.1"
+futures = "0.3.32"
+async-tungstenite = "0.17.0"
+futures-locks = "0.7.1"
+async-lock = "2.8.0"
+async-recursion = "1.0.4"
+tokio-util = { version = "0.7.18" }
+
+# Error Handling
+anyhow = "1.0.100"
+thiserror = "2.0.18"
+sentry = "0.31.5"
+sentry-anyhow = "0.38.1"
+
+# Data Validation
+regex = "1.12.3"
+validator = "0.16"
+
+# Data Types
+uuid = "1.19.0"
+ulid = "1.2.1"
+nanoid = "0.4.0"
+typenum = "1.17.0"
+num_enum = "0.6.1"
+bitfield = "0.13.2"
+
+# Time
+chrono = "0.4.15"
+iso8601-timestamp = "0.2.10"
+
+# Data Collections
+lru = "0.16.3"
+indexmap = "2.13.1"
+dashmap = "5.2.0"
+moka = "0.12.8"
+lru_time_cache = "0.11.11"
+deadqueue = "0.2.4"
+
+# Web scraping
+scraper = "0.20.0"
+encoding_rs = "0.8.34"
+
+# Mail
+lettre = "0.10.0-alpha.4"
+handlebars = "4.3.0"
+
+# HTTP Requests
+reqwest = "0.13.2"
+isahc = "1.7"
+
+# Notifications
+fcm_v1 = "0.3.0"
+web-push = "0.10.0"
+revolt_a2 = "0.10"
+
+# Parsing
+logos = "0.15"
+
+# SVG rendering
+usvg = "0.44.0"
+resvg = "0.44.0"
+tiny-skia = "0.11.4"
+
+# Logging
+log = "0.4.29"
+pretty_env_logger = "0.4.0"
+
+# Redis
+redis-kiss = { version = "0.1.4", default-features = false }
+fred = "8.0.1"
+
+# Serialisation
+bincode = "1.3.3"
+serde_json = "1.0.79"
+rmp-serde = "1.0.0"
+serde = { version = "1", features = ["derive"] }
+strum_macros = "0.26.4"
+
+# MongoDB
+bson = { version = "2.1.0" }
+mongodb = { version = "3.1.0" }
+
+# S3
+aws-config = "1.5.5"
+aws-sdk-s3 = "1.46.0"
+
+# Axum (HTTP server)
+axum-macros = "0.4.1"
+axum_typed_multipart = "0.12.1"
+axum = "0.7.5"
+axum-extra = "0.9"
+tower-http = "0.5.2"
+
+# Rocket (HTTP server)
+rocket = "0.5.1"
+rocket_empty = "0.1.1"
+revolt_rocket_okapi = "0.10.0"
+rocket_cors = { git = "https://github.com/lawliet89/rocket_cors", rev = "072d90359b23e9b291df6b672c07c93de9c46011" }
+rocket_authifier = "1.0.16"
+rocket_prometheus = "0.10.0-rc.3"
+
+# Spec Generation
+utoipa = "4.2.3"
+revolt_okapi = "0.9.1"
+schemars = "0.8.8"
+utoipa-scalar = "0.1.0"
+
+# Image Processing
+jxl-oxide = "0.12.5"
+sha2 = "0.10.8"
+kamadak-exif = "0.5.4"
+webp = "0.3.0"
+image = "0.25.2"  # avif encode requires dav1d system library: features = ["avif-native"]
+thumbhash = "0.1.0"
+lcms2 = "6.1.1" # for color profile processing
+
+# File processing
+revolt_clamav-client = "0.1.5"
+simdutf8 = "0.1.4"
+
+# Content type processing
+infer = "0.16.0"
+ffprobe = "0.4.0"
+imagesize = "0.13.0"
+
+# OpenTelemetry
+tracing = "0.1.44"
+tracing-subscriber = { version = "0.3.22", features = [
+    "env-filter",
+] } # consider https://crates.io/crates/better-tracing
+opentelemetry = { version = "0.31.0", features = ["logs"] }
+opentelemetry_sdk = { version = "0.31.0", features = ["logs"] }
+opentelemetry-otlp = { version = "0.31.0", features = ["logs"] }
+opentelemetry-appender-tracing = "0.31.1"
+
+# RabbitMQ
+lapin = "4.7.1"
+
+# Voice
+livekit-api = "=0.4.23"
+livekit-protocol = "=0.7.7"
+livekit-runtime = "0.4.0"
+
+# Other Utilities
+once_cell = "1.9.0"
+config = "0.13.3"
+cached = "0.44.0"
+rand = "0.8.5"
+base64 = "0.21.3"
+decancer = "3.3.3"
+linkify = "0.8.1"
+url-escape = "0.1.1"
+revolt_optional_struct = "0.2.0"
+unicode-segmentation = "1.10.1"
+querystring = "1.1.0"
+tempfile = "3.12.0"
+aes-gcm = "0.10.3"
+auto_ops = "0.3.0"
+url = "2.2.2"
+impl_ops = "0.1.1"
+lazy_static = "1.5.0"
+mime = "0.3.17"
+totp-lite = "2.0.0"
+rust-argon2 = "1.0.0"
+base32 = "0.4.0"
+sha1 = "0.10.6"
+futures-lite = "2.6.1"
+
+# Build Dependencies
+vergen = "7.5.0"
+
+# Local packages
+revolt-coalesced = { version = "0.13.7", path = "crates/core/coalesced" }
+revolt-config = { version = "0.13.7", path = "crates/core/config" }
+revolt-database = { version = "0.13.7", path = "crates/core/database" }
+revolt-files = { version = "0.13.7", path = "crates/core/files" }
+revolt-models = { version = "0.13.7", path = "crates/core/models" }
+revolt-parser = { version = "0.13.7", path = "crates/core/parser" }
+revolt-permissions = { version = "0.13.7", path = "crates/core/permissions" }
+revolt-presence = { version = "0.13.7", path = "crates/core/presence" }
+revolt-ratelimits = { version = "0.13.7", path = "crates/core/ratelimits" }
+revolt-result = { version = "0.13.7", path = "crates/core/result" }

Dockerfile

@@ -1,5 +1,5 @@
 # Build Stage
-FROM --platform="${BUILDPLATFORM}" rust:1.86.0-slim-bookworm
+FROM --platform="${BUILDPLATFORM}" rust:1.92.0-slim-bookworm
 USER 0:0
 WORKDIR /home/rust/src
 
@@ -27,10 +27,14 @@ COPY crates/core/parser/Cargo.toml ./crates/core/parser/
 COPY crates/core/permissions/Cargo.toml ./crates/core/permissions/
 COPY crates/core/presence/Cargo.toml ./crates/core/presence/
 COPY crates/core/result/Cargo.toml ./crates/core/result/
+COPY crates/core/coalesced/Cargo.toml ./crates/core/coalesced/
+COPY crates/core/ratelimits/Cargo.toml ./crates/core/ratelimits/
 COPY crates/services/autumn/Cargo.toml ./crates/services/autumn/
 COPY crates/services/january/Cargo.toml ./crates/services/january/
+COPY crates/services/gifbox/Cargo.toml ./crates/services/gifbox/
 COPY crates/daemons/crond/Cargo.toml ./crates/daemons/crond/
 COPY crates/daemons/pushd/Cargo.toml ./crates/daemons/pushd/
+COPY crates/daemons/voice-ingress/Cargo.toml ./crates/daemons/voice-ingress/
 RUN sh /tmp/build-image-layer.sh deps
 
 # Build all apps

Dockerfile.useCurrentArch

@@ -1,5 +1,5 @@
 # Build Stage
-FROM rust:1.86.0-slim-bookworm
+FROM rust:1.92.0-slim-bookworm
 USER 0:0
 WORKDIR /home/rust/src
 
@@ -23,10 +23,14 @@ COPY crates/core/parser/Cargo.toml ./crates/core/parser/
 COPY crates/core/permissions/Cargo.toml ./crates/core/permissions/
 COPY crates/core/presence/Cargo.toml ./crates/core/presence/
 COPY crates/core/result/Cargo.toml ./crates/core/result/
+COPY crates/core/coalesced/Cargo.toml ./crates/core/coalesced/
+COPY crates/core/ratelimits/Cargo.toml ./crates/core/ratelimits/
 COPY crates/services/autumn/Cargo.toml ./crates/services/autumn/
 COPY crates/services/january/Cargo.toml ./crates/services/january/
+COPY crates/services/gifbox/Cargo.toml ./crates/services/gifbox/
 COPY crates/daemons/crond/Cargo.toml ./crates/daemons/crond/
 COPY crates/daemons/pushd/Cargo.toml ./crates/daemons/pushd/
+COPY crates/daemons/voice-ingress/Cargo.toml ./crates/daemons/voice-ingress/
 RUN sh /tmp/build-image-layer.sh deps
 
 # Build all apps

README.md

@@ -1,15 +1,15 @@
 <div align="center">
 <h1>
-  Revolt Backend
+  Stoat Backend
   
-  [![Stars](https://img.shields.io/github/stars/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/stargazers)
-  [![Forks](https://img.shields.io/github/forks/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/network/members)
-  [![Pull Requests](https://img.shields.io/github/issues-pr/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/pulls)
-  [![Issues](https://img.shields.io/github/issues/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/issues)
-  [![Contributors](https://img.shields.io/github/contributors/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/graphs/contributors)
-  [![License](https://img.shields.io/github/license/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/blob/main/LICENSE)
+  [![Stars](https://img.shields.io/github/stars/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/stargazers)
+  [![Forks](https://img.shields.io/github/forks/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/network/members)
+  [![Pull Requests](https://img.shields.io/github/issues-pr/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/pulls)
+  [![Issues](https://img.shields.io/github/issues/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/issues)
+  [![Contributors](https://img.shields.io/github/contributors/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/graphs/contributors)
+  [![License](https://img.shields.io/github/license/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/blob/main/LICENSE)
 </h1>
-The services and libraries that power the Revolt service.<br/>
+The services and libraries that power the Stoat service.<br/>
 <br/>
 
 | Crate              | Path                                               | Description                         |                                                                                                                                                                                                                                                                                                           |
@@ -21,9 +21,11 @@ The services and libraries that power the Revolt service.<br/>
 | `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)                     |
+| `core/coalesced`   | [crates/core/coalesced](crates/core/coalesced)     | Core: Coalescion service            | ![Crates.io Version](https://img.shields.io/crates/v/revolt-coalesced) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-coalesced) ![Crates.io Version](https://img.shields.io/crates/size/revolt-coalesced) ![Crates.io License](https://img.shields.io/crates/l/revolt-coalesced)         |
 | `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/gifbox`  | [crates/services/gifbox](crates/services/gifbox)   | Tenor 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)                                                                                                                                                                                                                                |
@@ -35,22 +37,19 @@ The services and libraries that power the Revolt service.<br/>
 
 Rust 1.86.0 or higher.
 
-> [!CAUTION]
-> The events server has a significant performance regression between Rust 1.77.2 and 1.78.0 onwards, see [issue #341](https://github.com/revoltchat/backend/issues/341). This is currently solved by build time options but we are looking for a proper fix.
-
 ## Development Guide
 
-Before contributing, make yourself familiar with [our contribution guidelines](https://developers.revolt.chat/contrib.html) and the [technical documentation for this project](https://revoltchat.github.io/backend/).
+Before contributing, make yourself familiar with [our contribution guidelines](https://developers.stoat.chat/developing/contrib/) and the [technical documentation for this project](https://developers.stoat.chat/).
 
 Before getting started, you'll want to install:
 
-- Rust toolchain (rustup recommended)
+- mise
 - Docker
 - Git
 - mold (optional, faster compilation)
 
 > A **default.nix** is available for Nix users!
-> Just run `nix-shell` and continue.
+> Run `nix-shell` to activate mise.
 
 As a heads-up, the development environment uses the following ports:
 
@@ -66,15 +65,25 @@ As a heads-up, the development environment uses the following ports:
 | `crates/bonfire`          |     14703      |
 | `crates/services/autumn`  |     14704      |
 | `crates/services/january` |     14705      |
+| `crates/services/gifbox`  |     14706      |
 
 Now you can clone and build the project:
 
 ```bash
-git clone https://github.com/revoltchat/backend revolt-backend
-cd revolt-backend
-cargo build
+git clone https://github.com/stoatchat/stoatchat stoat-backend
+cd stoat-backend
+mise install
+mise build
 ```
 
+> [!TIP]
+> You can override `BUILDER` in your `.env` file to run cargo with mold if you installed it:
+>
+> ```bash
+> # .env
+> BUILDER = "mold --run cargo"
+> ```
+
 A default configuration `Revolt.toml` is present in this project that is suited for development.
 
 If you'd like to change anything, create a `Revolt.overrides.toml` file and specify relevant variables.
@@ -111,7 +120,7 @@ If you'd like to change anything, create a `Revolt.overrides.toml` file and spec
 >       - "14672:15672"
 > ```
 >
-> And corresponding Revolt configuration:
+> With the corresponding Revolt configuration:
 >
 > ```toml
 > #     Revolt.overrides.toml
@@ -123,51 +132,41 @@ If you'd like to change anything, create a `Revolt.overrides.toml` file and spec
 > [rabbit]
 > port = 14072
 > ```
+>
+> And mise configuration
+>
+> ```bash
+> #.env
+> DATABASE_PORT = "14017"
+> RABBIT_PORT = "14072"
+> REDIS_PORT = "14079"
+> ```
 
 Then continue:
 
 ```bash
-# start other necessary services
-docker compose up -d
+cp livekit.example.yml livekit.yml
 
-# run everything together
-./scripts/start.sh
-# .. or individually
-# run the API server
-cargo run --bin revolt-delta
-# run the events server
-cargo run --bin revolt-bonfire
-# run the file server
-cargo run --bin revolt-autumn
-# run the proxy server
-cargo run --bin revolt-january
-# run the push daemon (not usually needed in regular development)
-cargo run --bin revolt-pushd
-
-# hint:
-# mold -run <cargo build, cargo run, etc...>
-# mold -run ./scripts/start.sh
+mise start
 ```
 
-You can start a web client by doing the following:
+You can start a web client by doing the following in another terminal:
 
 ```bash
 # if you do not have yarn yet and have a modern Node.js:
 corepack enable
 
 # clone the web client and run it:
-git clone --recursive https://github.com/revoltchat/revite
-cd revite
-yarn
-yarn build:deps
-echo "VITE_API_URL=http://local.revolt.chat:14702" > .env.local
-yarn dev --port 14701
+git clone --recursive https://github.com/stoatchat/for-web stoat-web
+cd stoat-web
+# refer to stoat-web/README.md for startup, creating an account and loging in
 ```
 
-Then go to http://local.revolt.chat:14701 to create an account/login.
-
 When signing up, go to http://localhost:14080 to find confirmation/password reset emails.
 
+To stop all services, hit (CTRL + c) in the terminal you ran `mise start` and run `mise docker:stop`
+
+
 ## Deployment Guide
 
 ### Cutting new crate releases
@@ -196,14 +195,14 @@ Tag and push a new release by running:
 just release
 ```
 
-If you have bumped the crate versions, proceed to [GitHub releases](https://github.com/revoltchat/backend/releases/new) to create a changelog.
+If you have bumped the crate versions, proceed to [GitHub releases](https://github.com/stoatchat/stoatchat/releases/new) to create a changelog.
 
 ## Testing
 
 First, start the required services:
 
 ```sh
-docker compose -f docker-compose.db.yml up -d
+docker compose up -d
 ```
 
 Now run tests for whichever database:
@@ -215,6 +214,6 @@ TEST_DB=MONGODB cargo nextest run
 
 ## License
 
-The Revolt backend is generally licensed under the [GNU Affero General Public License v3.0](https://github.com/revoltchat/backend/blob/master/LICENSE).
+The Stoat backend is generally licensed under the [GNU Affero General Public License v3.0](https://github.com/stoatchat/stoatchat/blob/main/LICENSE).
 
 **Individual crates may supply their own licenses!**

Revolt.toml

@@ -15,7 +15,7 @@ host = "127.0.0.1"
 [hosts]
 # Web locations of various services
 # Defaults assume all services are reverse-proxied
-# See https://github.com/revoltchat/self-hosted/blob/master/Caddyfile
+# See https://github.com/stoatchat/self-hosted/blob/main/Caddyfile
 #
 # Remember to change these to https/wss where appropriate in production!
 app = "http://local.revolt.chat:14701"
@@ -26,6 +26,11 @@ january = "http://local.revolt.chat:14705"
 voso_legacy = ""
 voso_legacy_ws = ""
 
+# Public urls for livekit nodes
+# each entry here should have a corresponding entry under `api.livekit.nodes`
+[hosts.livekit]
+worldwide = "ws://local.revolt.chat:14706"
+
 [api]
 
 [api.smtp]
@@ -40,6 +45,18 @@ port = 14025
 use_tls = false
 use_starttls = false
 
+[api.livekit]
+
+# Config for livekit nodes
+# Make sure to change the secret when deploying
+# The key and secret should match the values livekit is using
+[api.livekit.nodes.worldwide]
+url = "http://livekit"
+lat = 0.0
+lon = 0.0
+key = "worldwide"
+secret = "ZjCofRlfm6GGtjlifmNpCDkcQbEIIVC0"
+
 [files.s3]
 # S3 protocol endpoint
 endpoint = "http://127.0.0.1:14009"

STYLE_GUIDE.md

@@ -1,73 +0,0 @@
-# Code Style Guide
-
-Beyond using Cargo format and Clippy, there are some specific code style guidelines laid out in this document for different parts of the project.
-
-## Writing Style
-
-- Shorten "identifier" to "Id" with that exact casing, i.e. Server Id.
-
-## `core/database` crate
-
-w.r.t. `model.rs` files
-
-- All struct definitions must be commented.
-  ```rust
-  /// Server
-  pub struct Server {
-    /// Name of the server
-    pub name: String,
-  ```
-- Struct definitions should not include derives unless necessary (if additional traits such as Hash are required) and instead use `auto_derived!` and `auto_derived_partial!`.
-  ```rust
-  auto_derived_partial!(
-    /// Server
-    pub struct Server { .. },
-    "PartialServer"
-  );
-  ```
-- `auto_derived!` macro accepts multiple entries and should be used as such:
-
-  ```rust
-  auto_derived!(
-    /// Optional fields on server object
-    pub enum FieldsServer { .. }
-
-    /// Optional fields on server object
-    pub enum FieldsRole { .. }
-  );
-  ```
-
-- If special serialisation conditions are required, such as checking if a boolean is false, use the existing definitions for these functions from the crate root:
-  ```rust
-  #[serde(skip_serializing_if = "crate::if_false", default)]
-  ```
-- `impl` blocks may be defined below the struct definitions and should be ordered in the same order of definition. Methods in the block must follow the same guidelines as traits where-in: methods are ordered in terms of CRUD, there are empty line breaks, and methods are commented.
-
-w.r.t. `ops` module for models
-
-- All traits must use a the name format `AbstractPlural` where Plural is the plural form of the collection. e.g. Servers
-- Traits defined must follow these guidelines:
-
-  - Methods are ordered in terms of CRUD, create-read-update-delete ordering.
-
-    ```rust
-    #[async_trait]
-    pub trait AbstractServerMembers: Sync + Send {
-      /// Insert a new server member into the database
-      async fn insert_member(&self, member: &Member) -> Result<()>;
-
-      /// Fetch a server member by their id
-      async fn fetch_member(&self, server_id: &str, user_id: &str) -> Result<Member>;
-
-      /// Update information for a server member
-      async fn update_member(&self, .. ) -> Result<()>;
-
-      /// Delete a server member by their id
-      async fn delete_member(&self, id: &MemberCompositeKey) -> Result<()>;
-    }
-    ```
-
-  - There should be an empty line break between each method declaration.
-  - All methods must have an appropriate comment.
-
-- When implementing the trait defined in `ops.rs` with each driver, the method declaration style should be the same for ease of searching: same ordering, same comments, same line breaks.

compose.yml

@@ -8,18 +8,33 @@ services:
   # MongoDB
   database:
     image: mongo
+    command: mongod --replSet rs0
     ports:
       - "27017:27017"
     volumes:
       - ./.data/db:/data/db
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    healthcheck:
+      test: echo "try { rs.status() } catch (err) { rs.initiate({_id:'rs0',members:[{_id:0,host:'127.0.0.1:27017'}]}) }" | mongosh --port 27017 --quiet
+      interval: 5s
+      timeout: 30s
+      start_period: 0s
+      start_interval: 1s
+      retries: 30
+    ulimits:
+      nofile:
+        soft: 65536
+        hard: 65536
 
   # MinIO
   minio:
-    image: minio/minio
-    command: server /data
+    image: firstfinger/minio:latest
+    #command: server /data
     environment:
       MINIO_ROOT_USER: minioautumn
       MINIO_ROOT_PASSWORD: minioautumn
+      MINIO_REGION: minio
     volumes:
       - ./.data/minio:/data
     ports:
@@ -40,7 +55,7 @@ services:
 
   # Rabbit
   rabbit:
-    image: rabbitmq:3-management
+    image: rabbitmq:4-management
     environment:
       RABBITMQ_DEFAULT_USER: rabbituser
       RABBITMQ_DEFAULT_PASS: rabbitpass
@@ -55,7 +70,7 @@ services:
 
   # Mock SMTP server
   maildev:
-    image: soulteary/maildev
+    image: maildev/maildev
     ports:
       - "14025:25"
       - "14080:8080"
@@ -64,3 +79,10 @@ services:
       MAILDEV_WEB_PORT: 8080
       MAILDEV_INCOMING_USER: smtp
       MAILDEV_INCOMING_PASS: smtp
+
+  livekit:
+    image: ghcr.io/stoatchat/livekit-server:v1.9.13
+    command: --config /etc/livekit.yml
+    network_mode: "host"
+    volumes:
+      - ./livekit.yml:/etc/livekit.yml

crates/bonfire/Cargo.toml

@@ -1,48 +1,46 @@
 [package]
 name = "revolt-bonfire"
-version = "0.8.8"
+version = "0.13.7"
 license = "AGPL-3.0-or-later"
 edition = "2021"
+publish = false
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
 # util
-log = "*"
-sentry = "0.31.5"
-lru = "0.7.6"
-ulid = "0.5.0"
-once_cell = "1.9.0"
-redis-kiss = "0.1.4"
-lru_time_cache = "0.11.11"
-async-channel = "2.3.1"
+log = { workspace = true }
+sentry = { workspace = true }
+lru = { workspace = true }
+ulid = { workspace = true }
+once_cell = { workspace = true }
+redis-kiss = { workspace = true, default-features = false, features = ["tokio-runtime"] }
+lru_time_cache = { workspace = true }
+async-channel = { workspace = true }
 
 # parsing
-querystring = "1.1.0"
+querystring = { workspace = true }
+regex = { workspace = true }
 
 # serde
-bincode = "1.3.3"
-serde_json = "1.0.79"
-rmp-serde = "1.0.0"
-serde = "1.0.136"
+bincode = { workspace = true }
+serde_json = { workspace = true }
+rmp-serde = { workspace = true }
+serde = { workspace = true }
 
 # async
-futures = "0.3.21"
-async-tungstenite = { version = "0.17.0", features = ["async-std-runtime"] }
-async-std = { version = "1.8.0", features = [
-    "tokio1",
-    "tokio02",
-    "attributes",
-] }
+futures = { workspace = true }
+async-tungstenite = { workspace = true, features = ["tokio-runtime"] }
+tokio = { workspace = true }
+tokio-util = { workspace = true, features = ["compat"] }
 
 # core
-authifier = { version = "1.0.15" }
-revolt-result = { path = "../core/result" }
-revolt-models = { path = "../core/models" }
-revolt-config = { path = "../core/config" }
-revolt-database = { path = "../core/database" }
-revolt-permissions = { version = "0.8.8", path = "../core/permissions" }
-revolt-presence = { path = "../core/presence", features = ["redis-is-patched"] }
+revolt-result = { workspace = true }
+revolt-models = { workspace = true }
+revolt-config = { workspace = true }
+revolt-database = { workspace = true, features = ["voice"] }
+revolt-permissions = { workspace = true }
+revolt-presence = { workspace = true, features = ["redis-is-patched"] }
 
 # redis
-fred = { version = "8.0.1", features = ["subscriber-client"] }
+fred = { workspace = true, features = ["subscriber-client"] }

crates/bonfire/Dockerfile

@@ -1,5 +1,5 @@
 # Build Stage
-FROM ghcr.io/revoltchat/base:latest AS builder
+FROM ghcr.io/stoatchat/base:latest AS builder
 FROM debian:12 AS debian
 
 # Bundle Stage

crates/bonfire/src/config.rs

@@ -1,9 +1,15 @@
 use async_tungstenite::tungstenite::{handshake, Message};
 use futures::channel::oneshot::Sender;
+use once_cell::sync::Lazy;
+use regex::Regex;
 use revolt_database::events::client::ReadyPayloadFields;
 use revolt_result::{create_error, Result};
 use serde::{Deserialize, Serialize};
 
+/// matches either a single word ie "users" or a key and value ie "settings[notifications]"
+static READY_PAYLOAD_FIELD_REGEX: Lazy<Regex> =
+    Lazy::new(|| Regex::new(r#"^(\w+)(?:\[(\S+)\])?$"#).unwrap());
+
 /// Enumeration of supported protocol formats
 #[derive(Debug)]
 pub enum ProtocolFormat {
@@ -17,6 +23,7 @@ pub struct ProtocolConfiguration {
     protocol_version: i32,
     format: ProtocolFormat,
     session_token: Option<String>,
+    ready_payload_fields: ReadyPayloadFields,
 }
 
 impl ProtocolConfiguration {
@@ -25,11 +32,13 @@ impl ProtocolConfiguration {
         protocol_version: i32,
         format: ProtocolFormat,
         session_token: Option<String>,
+        ready_payload_fields: ReadyPayloadFields,
     ) -> Self {
         Self {
             protocol_version,
             format,
             session_token,
+            ready_payload_fields,
         }
     }
 
@@ -86,14 +95,8 @@ impl ProtocolConfiguration {
     }
 
     /// Get ready payload fields
-    pub fn get_ready_payload_fields(&self) -> Vec<ReadyPayloadFields> {
-        vec![
-            ReadyPayloadFields::Users,
-            ReadyPayloadFields::Servers,
-            ReadyPayloadFields::Channels,
-            ReadyPayloadFields::Members,
-            ReadyPayloadFields::Emoji,
-        ]
+    pub fn get_ready_payload_fields(&self) -> &ReadyPayloadFields {
+        &self.ready_payload_fields
     }
 }
 
@@ -124,6 +127,23 @@ impl handshake::server::Callback for WebsocketHandshakeCallback {
         let mut protocol_version = 1;
         let mut format = ProtocolFormat::Json;
         let mut session_token = None;
+        let mut ready_payload_fields = if params.iter().any(|(k, _)| *k == "ready") {
+            // If they pass the ready field, set all fields to false
+
+            ReadyPayloadFields {
+                users: false,
+                servers: false,
+                channels: false,
+                members: false,
+                emojis: false,
+                voice_states: false,
+                user_settings: Vec::new(),
+                channel_unreads: false,
+                policy_changes: false,
+            }
+        } else {
+            ReadyPayloadFields::default()
+        };
 
         // Parse and map parameters from key-value to known variables.
         for (key, value) in params {
@@ -139,6 +159,31 @@ impl handshake::server::Callback for WebsocketHandshakeCallback {
                     _ => {}
                 },
                 "token" => session_token = Some(value.into()),
+                "ready" => {
+                    // Re-enable all the fields the client specifies
+                    if let Some(captures) = READY_PAYLOAD_FIELD_REGEX.captures(value) {
+                        if let Some(field) = captures.get(0) {
+                            match field.as_str() {
+                                "users" => ready_payload_fields.users = true,
+                                "servers" => ready_payload_fields.servers = true,
+                                "channels" => ready_payload_fields.channels = true,
+                                "members" => ready_payload_fields.members = true,
+                                "emojis" => ready_payload_fields.emojis = true,
+                                "voice_states" => ready_payload_fields.voice_states = true,
+                                "channel_unreads" => ready_payload_fields.channel_unreads = true,
+                                "user_settings" => {
+                                    if let Some(subkey) = captures.get(1) {
+                                        ready_payload_fields
+                                            .user_settings
+                                            .push(subkey.as_str().to_string());
+                                    }
+                                }
+                                "policy_changes" => ready_payload_fields.policy_changes = true,
+                                _ => {}
+                            }
+                        }
+                    }
+                }
                 _ => {}
             }
         }
@@ -151,6 +196,7 @@ impl handshake::server::Callback for WebsocketHandshakeCallback {
                 protocol_version,
                 format,
                 session_token,
+                ready_payload_fields,
             })
             .is_ok()
         {

crates/bonfire/src/events/impl.rs

@@ -1,9 +1,11 @@
-use std::collections::HashSet;
+use std::collections::{HashMap, HashSet};
 
 use futures::future::join_all;
+use redis_kiss::AsyncCommands;
 use revolt_database::{
     events::client::{EventV1, ReadyPayloadFields},
     util::permissions::DatabasePermissionQuery,
+    voice::{get_channel_voice_state, UserVoiceChannel},
     Channel, Database, Member, MemberCompositeKey, Presence, RelationshipStatus,
 };
 use revolt_models::v0;
@@ -17,8 +19,9 @@ use super::state::{Cache, State};
 impl Cache {
     /// Check whether the current user can view a channel
     pub async fn can_view_channel(&self, db: &Database, channel: &Channel) -> bool {
+        #[allow(deprecated)]
         match &channel {
-            Channel::TextChannel { server, .. } | Channel::VoiceChannel { server, .. } => {
+            Channel::TextChannel { server, .. } => {
                 let member = self.members.get(server);
                 let server = self.servers.get(server);
                 let mut query =
@@ -95,21 +98,23 @@ impl State {
     pub async fn generate_ready_payload(
         &mut self,
         db: &Database,
-        fields: Vec<ReadyPayloadFields>,
+        fields: &ReadyPayloadFields,
     ) -> Result<EventV1> {
         let user = self.clone_user();
         self.cache.is_bot = user.bot.is_some();
 
         // Fetch pending policy changes.
-        let policy_changes = if user.bot.is_some() {
-            vec![]
+        let policy_changes = if user.bot.is_some() || !fields.policy_changes {
+            None
         } else {
-            db.fetch_policy_changes()
-                .await?
-                .into_iter()
-                .filter(|policy| policy.created_time > user.last_acknowledged_policy_change)
-                .map(Into::into)
-                .collect()
+            Some(
+                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.
@@ -120,12 +125,7 @@ impl State {
             .unwrap_or_default();
 
         // Fetch all memberships with their corresponding servers.
-        let members: Vec<Member> = db.fetch_all_memberships(&user.id).await?;
-        self.cache.members = members
-            .iter()
-            .cloned()
-            .map(|x| (x.id.server.clone(), x))
-            .collect();
+        let mut members: Vec<Member> = db.fetch_all_memberships(&user.id).await?;
 
         let server_ids: Vec<String> = members.iter().map(|x| x.id.server.clone()).collect();
         let servers = db.fetch_servers(&server_ids).await?;
@@ -154,6 +154,55 @@ impl State {
             }
         }
 
+        let voice_states = if fields.voice_states {
+            let mut voice_state_server_members: HashMap<String, HashSet<String>> = HashMap::new();
+
+            // fetch voice states for all the channels we can see
+            let mut voice_states = Vec::new();
+
+            for channel in channels.iter().filter(|c| {
+                matches!(
+                    c,
+                    Channel::DirectMessage { .. }
+                        | Channel::Group { .. }
+                        | Channel::TextChannel { voice: Some(_), .. }
+                )
+            }) {
+                if let Ok(Some(voice_state)) =
+                    get_channel_voice_state(&UserVoiceChannel::from_channel(channel)).await
+                {
+                    if let Some(server) = channel.server() {
+                        let set = voice_state_server_members
+                            .entry(server.to_string())
+                            .or_default();
+
+                        for participant in &voice_state.participants {
+                            user_ids.insert(participant.id.clone());
+                            set.insert(participant.id.clone());
+                        }
+                    } else {
+                        for participant in &voice_state.participants {
+                            user_ids.insert(participant.id.clone());
+                        }
+                    }
+
+                    voice_states.push(voice_state);
+                }
+            }
+
+            // Fetch all the members for for the participants who are in a server
+            for (server, user_ids) in voice_state_server_members {
+                let user_ids = user_ids.into_iter().collect::<Vec<_>>();
+                let voice_members = db.fetch_members(&server, &user_ids).await?;
+
+                members.extend(voice_members);
+            }
+
+            Some(voice_states)
+        } else {
+            None
+        };
+
         // Fetch presence data for known users.
         let online_ids = filter_online(&user_ids.iter().cloned().collect::<Vec<String>>()).await;
 
@@ -167,8 +216,14 @@ impl State {
             )
             .await?;
 
+        self.cache.members = members
+            .iter()
+            .cloned()
+            .map(|x| (x.id.server.clone(), x))
+            .collect();
+
         // Fetch customisations.
-        let emojis = if fields.contains(&ReadyPayloadFields::Emoji) {
+        let emojis = if fields.emojis {
             Some(
                 db.fetch_emoji_by_parent_ids(
                     &servers
@@ -176,25 +231,34 @@ impl State {
                         .map(|x| x.id.to_string())
                         .collect::<Vec<String>>(),
                 )
-                .await?,
+                .await?
+                .into_iter()
+                .map(|emoji| emoji.into())
+                .collect(),
             )
         } else {
             None
         };
 
         // Fetch user settings
-        let user_settings = if let Some(ReadyPayloadFields::UserSettings(keys)) = fields
-            .iter()
-            .find(|e| matches!(e, ReadyPayloadFields::UserSettings(_)))
-        {
-            Some(db.fetch_user_settings(&user.id, keys).await?)
+        let user_settings = if !fields.user_settings.is_empty() {
+            Some(
+                db.fetch_user_settings(&user.id, &fields.user_settings)
+                    .await?,
+            )
         } else {
             None
         };
 
         // Fetch channel unreads
-        let channel_unreads = if fields.contains(&ReadyPayloadFields::ChannelUnreads) {
-            Some(db.fetch_unreads(&user.id).await?)
+        let channel_unreads = if fields.channel_unreads {
+            Some(
+                db.fetch_unreads(&user.id)
+                    .await?
+                    .into_iter()
+                    .map(|unread| unread.into())
+                    .collect(),
+            )
         } else {
             None
         };
@@ -241,30 +305,27 @@ impl State {
         }
 
         Ok(EventV1::Ready {
-            users: if fields.contains(&ReadyPayloadFields::Users) {
-                Some(users)
-            } else {
-                None
-            },
-            servers: if fields.contains(&ReadyPayloadFields::Servers) {
+            users: if fields.users { Some(users) } else { None },
+            servers: if fields.servers {
                 Some(servers.into_iter().map(Into::into).collect())
             } else {
                 None
             },
-            channels: if fields.contains(&ReadyPayloadFields::Channels) {
+            channels: if fields.channels {
                 Some(channels.into_iter().map(Into::into).collect())
             } else {
                 None
             },
-            members: if fields.contains(&ReadyPayloadFields::Members) {
+            members: if fields.members {
                 Some(members.into_iter().map(Into::into).collect())
             } else {
                 None
             },
-            emojis: emojis.map(|vec| vec.into_iter().map(Into::into).collect()),
+            voice_states,
 
+            emojis,
             user_settings,
-            channel_unreads: channel_unreads.map(|vec| vec.into_iter().map(Into::into).collect()),
+            channel_unreads,
 
             policy_changes,
         })
@@ -279,19 +340,14 @@ impl State {
 
             let id = &id.to_string();
             for (channel_id, channel) in &self.cache.channels {
-                match channel {
-                    Channel::TextChannel { server, .. } | Channel::VoiceChannel { server, .. } => {
-                        if server == id {
-                            channel_ids.insert(channel_id.clone());
+                if channel.server() == Some(id) {
+                    channel_ids.insert(channel_id.clone());
 
-                            if self.cache.can_view_channel(db, channel).await {
-                                added_channels.push(channel_id.clone());
-                            } else {
-                                removed_channels.push(channel_id.clone());
-                            }
-                        }
+                    if self.cache.can_view_channel(db, channel).await {
+                        added_channels.push(channel_id.clone());
+                    } else {
+                        removed_channels.push(channel_id.clone());
                     }
-                    _ => {}
                 }
             }
 
@@ -346,6 +402,11 @@ impl State {
 
     /// Push presence change to the user and all associated server topics
     pub async fn broadcast_presence_change(&self, target: bool) {
+        let config = revolt_config::config().await;
+        if config.disable_events_dont_use {
+            return;
+        }
+
         if if let Some(status) = &self.cache.users.get(&self.cache.user_id).unwrap().status {
             status.presence != Some(Presence::Invisible)
         } else {
@@ -459,6 +520,7 @@ impl State {
                 server,
                 channels,
                 emojis: _,
+                voice_states: _,
             } => {
                 self.insert_subscription(id.clone()).await;
 

crates/bonfire/src/events/state.rs

@@ -1,10 +1,8 @@
 use std::{
-    collections::{HashMap, HashSet},
-    sync::Arc,
-    time::Duration,
+    collections::{HashMap, HashSet}, num::NonZeroUsize, sync::Arc, time::Duration
 };
 
-use async_std::sync::{Mutex, RwLock};
+use tokio::sync::{Mutex, RwLock};
 use lru::LruCache;
 use lru_time_cache::{LruCache as LruTimeCache, TimedEntry};
 use revolt_database::{Channel, Member, Server, User};
@@ -57,7 +55,7 @@ impl Default for Cache {
             members: Default::default(),
             servers: Default::default(),
 
-            seen_events: LruCache::new(20),
+            seen_events: LruCache::new(NonZeroUsize::new(20).unwrap()),
         }
     }
 }

crates/bonfire/src/main.rs

@@ -1,6 +1,6 @@
 use std::env;
 
-use async_std::net::TcpListener;
+use tokio::net::TcpListener;
 use revolt_presence::clear_region;
 
 #[macro_use]
@@ -12,7 +12,7 @@ pub mod events;
 mod database;
 mod websocket;
 
-#[async_std::main]
+#[tokio::main]
 async fn main() {
     // Configure requirements for Bonfire.
     revolt_config::configure!(events);
@@ -33,7 +33,7 @@ async fn main() {
 
     // Start accepting new connections and spawn a client for each connection.
     while let Ok((stream, addr)) = listener.accept().await {
-        async_std::task::spawn(async move {
+        tokio::task::spawn(async move {
             info!("User connected from {addr:?}");
             websocket::client(database::get_db(), stream, addr).await;
             info!("User disconnected from {addr:?}");

crates/bonfire/src/websocket.rs

@@ -1,11 +1,10 @@
 use std::{collections::HashSet, net::SocketAddr, sync::Arc};
 
 use async_tungstenite::WebSocketStream;
-use authifier::AuthifierEvent;
 use fred::{
     error::RedisErrorKind,
     interfaces::{ClientLike, EventInterface, PubsubInterface},
-    types::RedisConfig,
+    types::{ReconnectPolicy, RedisConfig},
 };
 use futures::{
     channel::oneshot,
@@ -13,7 +12,7 @@ use futures::{
     stream::{SplitSink, SplitStream},
     FutureExt, SinkExt, StreamExt, TryStreamExt,
 };
-use redis_kiss::{PayloadType, REDIS_PAYLOAD_TYPE, REDIS_URI};
+use redis_kiss::{get_connection, AsyncCommands, PayloadType, REDIS_PAYLOAD_TYPE, REDIS_URI};
 use revolt_config::report_internal_error;
 use revolt_database::{
     events::{client::EventV1, server::ClientMessage},
@@ -22,19 +21,21 @@ use revolt_database::{
 };
 use revolt_presence::{create_session, delete_session};
 
-use async_std::{
+use tokio::{
     net::TcpStream,
     sync::{Mutex, RwLock},
     task::spawn,
 };
+use tokio_util::compat::{TokioAsyncReadCompatExt, Compat};
 use revolt_result::create_error;
 use sentry::Level;
 
 use crate::config::{ProtocolConfiguration, WebsocketHandshakeCallback};
 use crate::events::state::{State, SubscriptionStateChange};
+use revolt_models::v0;
 
-type WsReader = SplitStream<WebSocketStream<TcpStream>>;
-type WsWriter = SplitSink<WebSocketStream<TcpStream>, async_tungstenite::tungstenite::Message>;
+type WsReader = SplitStream<WebSocketStream<Compat<TcpStream>>>;
+type WsWriter = SplitSink<WebSocketStream<Compat<TcpStream>>, async_tungstenite::tungstenite::Message>;
 
 /// Start a new WebSocket client worker given access to the database,
 /// the relevant TCP stream and the remote address of the client.
@@ -44,7 +45,7 @@ pub async fn client(db: &'static Database, stream: TcpStream, addr: SocketAddr)
     // e.g. wss://example.com?format=json&version=1
     let (sender, receiver) = oneshot::channel();
     let Ok(ws) = async_tungstenite::accept_hdr_async_with_config(
-        stream,
+        stream.compat(),
         WebsocketHandshakeCallback::from(sender),
         None,
     )
@@ -128,6 +129,14 @@ pub async fn client(db: &'static Database, stream: TcpStream, addr: SocketAddr)
         return;
     }
 
+    let slowmodes = fetch_user_slowmodes(&user_id).await.unwrap_or_default();
+    if !slowmodes.is_empty() {
+        let event = EventV1::UserSlowmodes { slowmodes };
+        if report_internal_error!(write.send(config.encode(&event)).await).is_err() {
+            return;
+        }
+    }
+
     // Create presence session.
     let (first_session, session_id) = create_session(&user_id, 0).await;
 
@@ -218,10 +227,16 @@ async fn listener(
     kill_signal_r: async_channel::Receiver<()>,
     write: &Mutex<WsWriter>,
 ) {
-    let redis_config = RedisConfig::from_url(&REDIS_URI).unwrap();
-    let subscriber = match report_internal_error!(
-        fred::types::Builder::from_config(redis_config).build_subscriber_client()
-    ) {
+    let stoat_config = revolt_config::config().await;
+    let url = stoat_config
+        .database
+        .redis_pubsub
+        .unwrap_or(REDIS_URI.to_string());
+
+    let redis_config = RedisConfig::from_url(&url).unwrap();
+    let mut builder = fred::types::Builder::from_config(redis_config);
+    builder.set_policy(ReconnectPolicy::new_exponential(8, 100, 30_000, 2));
+    let subscriber = match report_internal_error!(builder.build_subscriber_client()) {
         Ok(subscriber) => subscriber,
         Err(_) => return,
     };
@@ -230,16 +245,21 @@ async fn listener(
         return;
     }
 
+    // Let Fred automatically re-subscribe to tracked channels on reconnect.
+    subscriber.manage_subscriptions();
+
     // Handle Redis connection dropping
     let (clean_up_s, clean_up_r) = async_channel::bounded(1);
     let clean_up_s = Arc::new(Mutex::new(clean_up_s));
     subscriber.on_error(move |err| {
+        warn!("Redis subscriber error: {:?}", err);
         if let RedisErrorKind::Canceled = err.kind() {
             let clean_up_s = clean_up_s.clone();
             spawn(async move {
                 clean_up_s.lock().await.send(()).await.ok();
             });
         }
+        // Transient errors (IO, timeout) are handled by the reconnect policy.
 
         Ok(())
     });
@@ -335,22 +355,20 @@ async fn listener(
                     break 'out;
                 };
 
-                if let EventV1::Auth(auth) = &event {
-                    if let AuthifierEvent::DeleteSession { session_id, .. } = auth {
-                        if &state.session_id == session_id {
-                            event = EventV1::Logout;
-                        }
-                    } else if let AuthifierEvent::DeleteAllSessions {
-                        exclude_session_id, ..
-                    } = auth
-                    {
-                        if let Some(excluded) = exclude_session_id {
-                            if &state.session_id != excluded {
-                                event = EventV1::Logout;
-                            }
-                        } else {
+                if let EventV1::DeleteSession { session_id, .. } = &event {
+                    if &state.session_id == session_id {
+                        event = EventV1::Logout;
+                    }
+                } else if let EventV1::DeleteAllSessions {
+                    exclude_session_id, ..
+                } = &event
+                {
+                    if let Some(excluded) = exclude_session_id {
+                        if &state.session_id != excluded {
                             event = EventV1::Logout;
                         }
+                    } else {
+                        event = EventV1::Logout;
                     }
                 } else {
                     let should_send = state.handle_incoming_event_v1(db, &mut event).await;
@@ -422,6 +440,8 @@ async fn worker(
     mut read: WsReader,
     write: &Mutex<WsWriter>,
 ) {
+    let revolt_config = revolt_config::config().await;
+
     loop {
         let t1 = read.try_next().fuse();
         let t2 = kill_signal_r.recv().fuse();
@@ -458,6 +478,10 @@ async fn worker(
 
                 match payload {
                     ClientMessage::BeginTyping { channel } => {
+                        if revolt_config.disable_events_dont_use {
+                            continue;
+                        }
+
                         if !subscribed.read().await.contains(&channel) {
                             continue;
                         }
@@ -470,6 +494,10 @@ async fn worker(
                         .await;
                     }
                     ClientMessage::EndTyping { channel } => {
+                        if revolt_config.disable_events_dont_use {
+                            continue;
+                        }
+
                         if !subscribed.read().await.contains(&channel) {
                             continue;
                         }
@@ -507,3 +535,42 @@ async fn worker(
         }
     }
 }
+
+async fn fetch_user_slowmodes(user_id: &str) -> Option<Vec<v0::ChannelSlowmode>> {
+    let mut conn = get_connection().await.ok()?.into_inner();
+    let idx_key = format!("slowmode_idx:{}", user_id);
+
+    let channel_ids: Vec<String> = conn.smembers(&idx_key).await.unwrap_or_default();
+    if channel_ids.is_empty() {
+        return Some(vec![]);
+    }
+
+    // Bulk fetch all TTLs in one round trip
+    let mut pipe = redis_kiss::redis::pipe();
+    for channel_id in &channel_ids {
+        pipe.ttl(format!("slowmode:{}:{}", user_id, channel_id));
+    }
+    let ttls: Vec<i64> = pipe.query_async(&mut conn).await.unwrap_or_default();
+
+    // Partition into alive/expired in one pass
+    let mut slowmodes = vec![];
+    let mut expired = vec![];
+    for (channel_id, ttl) in channel_ids.iter().zip(ttls.iter()) {
+        if *ttl > 0 {
+            slowmodes.push(v0::ChannelSlowmode {
+                channel_id: channel_id.clone(),
+                duration: *ttl as u64,
+                retry_after: *ttl as u64,
+            });
+        } else {
+            expired.push(channel_id.as_str());
+        }
+    }
+
+    // Bulk remove all expired members in one SREM call
+    if !expired.is_empty() {
+        conn.srem::<_, _, ()>(&idx_key, expired).await.ok();
+    }
+
+    Some(slowmodes)
+}

crates/core/coalesced/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "revolt-coalesced"
+version = "0.13.7"
+edition = "2021"
+license = "MIT"
+authors = ["Paul Makles <me@insrt.uk>", "Zomatree <me@zomatree.live>"]
+description = "Revolt Backend: Coalescion service"
+repository = "https://github.com/stoatchat/stoatchat"
+
+[features]
+tokio = ["dep:tokio"]
+queue = ["dep:indexmap"]
+cache = ["dep:lru"]
+
+default = ["tokio"]
+
+[dependencies]
+tokio = { workspace = true, features = ["sync"], optional = true }
+indexmap = { workspace = true, optional = true }
+lru = { workspace = true, optional = true }
+
+[dev-dependencies]
+tokio = { workspace = true, features = [
+    "rt",
+    "rt-multi-thread",
+    "macros",
+    "time",
+] }

crates/core/coalesced/LICENSE

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

crates/core/coalesced/src/config.rs

@@ -0,0 +1,24 @@
+#[derive(Clone, PartialEq, Eq, Debug)]
+/// Config values for [`CoalescionService`].
+pub struct CoalescionServiceConfig {
+    /// How many tasks are running at once
+    pub max_concurrent: Option<usize>,
+    /// Whether to queue tasks once `max_concurrent` is reached
+    #[cfg(feature = "queue")]
+    pub queue_requests: bool,
+    /// Max amount of tasks in the buffer queue
+    #[cfg(feature = "queue")]
+    pub max_queue: Option<usize>,
+}
+
+impl Default for CoalescionServiceConfig {
+    fn default() -> Self {
+        Self {
+            max_concurrent: Some(100),
+            #[cfg(feature = "queue")]
+            queue_requests: true,
+            #[cfg(feature = "queue")]
+            max_queue: Some(100)
+        }
+    }
+}

crates/core/coalesced/src/error.rs

@@ -0,0 +1,27 @@
+use std::fmt;
+
+#[derive(Clone, Copy, PartialEq, Eq, Debug, Hash)]
+/// Coalescion service error.
+pub enum Error {
+    /// Failed to receive the actions return from the channel for unknown reason
+    RecvError,
+    /// Reached the `max_concurrent` amount of actions running at once and could not queue the action
+    MaxConcurrent,
+    /// Reached the `max_queue` amount of actions in the queue
+    MaxQueue,
+    /// Failed to downcast the type to the current type being returned, this will be most likely an ID collision
+    DowncastError,
+}
+
+impl fmt::Display for Error {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            Error::RecvError => write!(f, "Unable to receive data from the channel"),
+            Error::MaxConcurrent => write!(f, "Max number of tasks running at once"),
+            Error::MaxQueue => write!(f, "Max number of tasks in queue"),
+            Error::DowncastError => write!(f, "Failed to downcast type, possible key collision with different types")
+        }
+    }
+}
+
+impl std::error::Error for Error {}

crates/core/coalesced/src/lib.rs

@@ -0,0 +1,39 @@
+//! # Coalesced
+//!
+//! Coalescion service to group, caching and queue duplicate actions.
+//! useful for deduplicating web requests, database lookups and other similar resource
+//! intensive or rate-limited actions.
+//!
+//! ## Features
+//! - `tokio`: Uses tokio for the async backend, this is currently the only backend.
+//! - `queue`: Whether to support queueing requests to only allow X amount of actions running at once.
+//! - `cache`: Whether to cache the actions results for future actions with the same id, uses an LRU cache internally.
+//!
+//! [`CoalescionService`] uses both [`Arc`] and [`RwLock`] internally and can be cheaply cloned to
+//! use in your codebase.
+//!
+//! It is common practice to wrap the service and in your own which delegates the executions to ensure all ids are tracked in one location across your codebase.
+//!
+//! All values are stored using [`Any`] and must be [`'static`] + [`Send`] + [`Sync`], if there is an id mismatch
+//! and a type is wrong the library will return an error, values returned from the service are also
+//! wrapped in an [`Arc`] as they are shared to each duplicate action.
+//!
+//! ## Example:
+//! ```rs
+//! use revolt_coalesced::CoalescionService;
+//!
+//! let service = CoalescionService::new();
+//!
+//! let user_id = "my_user_id";
+//! let user = service.execute(user_id, || async move {
+//!     database.fetch_user(user_id).await.unwrap()
+//! }).await;
+//! ```
+
+mod config;
+mod error;
+mod service;
+
+pub use config::CoalescionServiceConfig;
+pub use error::Error;
+pub use service::CoalescionService;

crates/core/coalesced/src/service.rs

@@ -0,0 +1,208 @@
+use std::{any::Any, collections::HashMap, fmt::Debug, future::Future, hash::Hash, sync::Arc};
+
+use tokio::sync::{
+    watch::{channel as watch_channel, Receiver},
+    RwLock,
+};
+
+#[cfg(feature = "cache")]
+use lru::LruCache;
+
+#[cfg(feature = "queue")]
+use indexmap::IndexMap;
+
+use crate::{CoalescionServiceConfig, Error};
+
+#[derive(Debug, Clone)]
+#[allow(clippy::type_complexity)]
+/// # Coalescion service
+///
+/// See module description for example usage.
+pub struct CoalescionService<Id: Hash + Clone + Eq> {
+    config: Arc<CoalescionServiceConfig>,
+    watchers: Arc<RwLock<HashMap<Id, Receiver<Option<Result<Arc<dyn Any + Send + Sync>, Error>>>>>>,
+    #[cfg(feature = "queue")]
+    queue: Arc<RwLock<IndexMap<Id, Receiver<Option<Result<Arc<dyn Any + Send + Sync>, Error>>>>>>,
+    #[cfg(feature = "cache")]
+    cache: Option<Arc<tokio::sync::Mutex<LruCache<Id, Arc<dyn Any + Send + Sync>>>>>,
+}
+
+impl<Id: Hash + Clone + Eq> CoalescionService<Id> {
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    pub fn from_config(config: CoalescionServiceConfig) -> Self {
+        Self {
+            config: Arc::new(config),
+            watchers: Arc::new(RwLock::new(HashMap::new())),
+            #[cfg(feature = "queue")]
+            queue: Arc::new(RwLock::new(IndexMap::new())),
+            #[cfg(feature = "cache")]
+            cache: None,
+        }
+    }
+
+    #[cfg(feature = "cache")]
+    pub fn from_cache(
+        config: CoalescionServiceConfig,
+        cache: LruCache<Id, Arc<dyn Any + Send + Sync>>,
+    ) -> Self {
+        Self {
+            cache: Some(Arc::new(Mutex::new(cache))),
+            ..Self::from_config(config)
+        }
+    }
+
+    async fn wait_for<Value: Any + Send + Sync>(
+        &self,
+        mut receiver: Receiver<Option<Result<Arc<dyn Any + Send + Sync>, Error>>>,
+    ) -> Result<Arc<Value>, Error> {
+        receiver
+            .wait_for(|v| v.is_some())
+            .await
+            .map_err(|_| Error::RecvError)
+            .and_then(|r| r.clone().unwrap())
+            .and_then(|arc| Arc::downcast(arc).map_err(|_| Error::DowncastError))
+    }
+
+    async fn insert_and_execute<
+        Value: Send + Sync + 'static,
+        F: FnOnce() -> Fut,
+        Fut: Future<Output = Value>,
+    >(
+        &self,
+        id: Id,
+        func: F,
+    ) -> Result<Arc<Value>, Error> {
+        let (send, recv) = watch_channel(None);
+
+        self.watchers.write().await.insert(id.clone(), recv);
+
+        let value = Ok(Arc::new(func().await));
+
+        send.send_modify(|opt| {
+            opt.replace(value.clone().map(|v| v as Arc<dyn Any + Send + Sync>));
+        });
+
+        #[cfg(feature = "cache")]
+        if let Some(cache) = self.cache.as_ref() {
+            if let Ok(value) = &value {
+                cache.lock().await.push(id.clone(), value.clone());
+            }
+        };
+
+        self.watchers.write().await.remove(&id);
+
+        value
+    }
+
+    /// Coalesces an function, the actual function may not run if one with the same id is already running,
+    /// queued to be ran, or cached, the id should be globally unique for this specific action.
+    pub async fn execute<
+        Value: Send + Sync + 'static,
+        F: FnOnce() -> Fut,
+        Fut: Future<Output = Value>,
+    >(
+        &self,
+        id: Id,
+        func: F,
+    ) -> Result<Arc<Value>, Error> {
+        #[cfg(feature = "cache")]
+        if let Some(cache) = self.cache.as_ref() {
+            if let Some(value) = cache.lock().await.get(&id) {
+                return Arc::downcast::<Value>(value.clone()).map_err(|_| Error::DowncastError);
+            }
+        };
+
+        let (receiver, length) = {
+            let watchers = self.watchers.read().await;
+            let length = watchers.len();
+
+            (watchers.get(&id).cloned(), length)
+        };
+
+        if let Some(receiver) = receiver {
+            self.wait_for(receiver).await
+        } else {
+            match self.config.max_concurrent {
+                Some(max_concurrent) if length >= max_concurrent => {
+                    #[cfg(feature = "queue")]
+                    if self.config.queue_requests {
+                        let (receiver, length) = {
+                            let queue = self.queue.read().await;
+
+                            (queue.get(&id).cloned(), queue.len())
+                        };
+
+                        if let Some(receiver) = receiver {
+                            return self.wait_for(receiver).await;
+                        } else {
+                            if self
+                                .config
+                                .max_queue
+                                .is_some_and(|max_queue| max_queue >= length)
+                            {
+                                return Err(Error::MaxQueue);
+                            };
+
+                            let (send, recv) = watch_channel(None);
+
+                            self.queue.write().await.insert(id.clone(), recv);
+
+                            loop {
+                                let length = self.watchers.read().await.len();
+
+                                if length < max_concurrent {
+                                    let first_key = {
+                                        let queue = self.queue.read().await;
+                                        queue.first().map(|v| v.0).cloned()
+                                    };
+
+                                    if first_key == Some(id.clone()) {
+                                        self.queue.write().await.shift_remove(&id);
+
+                                        let response = self.insert_and_execute(id, func).await;
+
+                                        send.send_modify(|opt| {
+                                            opt.replace(
+                                                response
+                                                    .clone()
+                                                    .map(|v| v as Arc<dyn Any + Send + Sync>),
+                                            );
+                                        });
+
+                                        return response;
+                                    }
+                                }
+                            }
+                        }
+                    } else {
+                        Err(Error::MaxConcurrent)
+                    }
+
+                    #[cfg(not(feature = "queue"))]
+                    Err(Error::MaxConcurrent)
+                }
+                _ => self.insert_and_execute(id, func).await,
+            }
+        }
+    }
+
+    /// Fetches the amount of currently running tasks
+    pub async fn current_task_count(&self) -> usize {
+        self.watchers.read().await.len()
+    }
+
+    #[cfg(feature = "queue")]
+    /// Fetches the current length of the queue
+    pub async fn current_queue_len(&self) -> usize {
+        self.queue.read().await.len()
+    }
+}
+
+impl<Id: Hash + Clone + Eq> Default for CoalescionService<Id> {
+    fn default() -> Self {
+        Self::from_config(CoalescionServiceConfig::default())
+    }
+}

crates/core/config/Cargo.toml

@@ -1,10 +1,11 @@
 [package]
 name = "revolt-config"
-version = "0.8.8"
+version = "0.13.7"
 edition = "2021"
 license = "MIT"
 authors = ["Paul Makles <me@insrt.uk>"]
 description = "Revolt Backend: Configuration"
+repository = "https://github.com/stoatchat/stoatchat"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
@@ -12,29 +13,28 @@ description = "Revolt Backend: Configuration"
 anyhow = ["dep:sentry-anyhow"]
 report-macros = ["revolt-result"]
 sentry = ["dep:sentry"]
-test = ["async-std"]
-default = ["test", "sentry"]
+test = ["tokio"]
+default = ["sentry"]
 
 [dependencies]
 # Utility
-config = "0.13.3"
-cached = "0.44.0"
-once_cell = "1.18.0"
+config = { workspace = true }
+cached = { workspace = true }
 
 # Serde
-serde = { version = "1", features = ["derive"] }
+serde = { workspace = true }
 
 # Async
-futures-locks = "0.7.1"
-async-std = { version = "1.8.0", features = ["attributes"], optional = true }
+futures-locks = { workspace = true }
+tokio = { workspace = true, optional = true }
 
 # Logging
-log = "0.4.14"
-pretty_env_logger = "0.4.0"
+log = { workspace = true }
+pretty_env_logger = { workspace = true }
 
 # Sentry
-sentry = { version = "0.31.5", optional = true }
-sentry-anyhow = { version = "0.38.1", optional = true }
+sentry = { workspace = true, optional = true }
+sentry-anyhow = { workspace = true, optional = true }
 
 # Core
-revolt-result = { version = "0.8.8", path = "../result", optional = true }
+revolt-result = { workspace = true, optional = true }

crates/core/config/Revolt.test.toml

@@ -1,3 +1,5 @@
+environment = "test"
+
 [database]
 mongodb = "mongodb://localhost"
 redis = "redis://localhost/"
@@ -10,3 +12,12 @@ password = "rabbitpass"
 
 [features]
 webhooks_enabled = true
+
+[api.smtp]
+host = "localhost"
+username = "smtp"
+password = "smtp"
+from_address = "development@stoat.chat"
+reply_to = "support@stoat.chat"
+port = 14025
+use_tls = false

crates/core/config/Revolt.toml

@@ -1,4 +1,6 @@
 production = false
+disable_events_dont_use = false
+environment = "dev"
 
 [database]
 # MongoDB connection URL
@@ -11,7 +13,7 @@ redis = "redis://redis/"
 [hosts]
 # Web locations of various services
 # Defaults assume all services are reverse-proxied
-# See https://github.com/revoltchat/self-hosted/blob/master/Caddyfile
+# See https://github.com/stoatchat/self-hosted/blob/main/Caddyfile
 #
 # Remember to change these to https/wss where appropriate in production!
 app = "http://local.revolt.chat"
@@ -22,17 +24,23 @@ january = "http://local.revolt.chat/january"
 voso_legacy = ""
 voso_legacy_ws = ""
 
+[hosts.livekit]
+
 [rabbit]
 host = "rabbit"
 port = 5672
 username = "rabbituser"
 password = "rabbitpass"
+default_exchange = "revolt.default"
+
+[rabbit.queues]
+acks = "internal.ack"
 
 [api]
 
 [api.registration]
 # Whether an invite should be required for registration
-# See https://github.com/revoltchat/self-hosted#making-your-instance-invite-only
+# See https://github.com/stoatchat/self-hosted#making-your-instance-invite-only
 invite_only = false
 
 [api.smtp]
@@ -46,6 +54,10 @@ from_address = "noreply@example.com"
 # port = 587
 # use_tls = true
 
+[api.smtp.expiry]
+expire_verification = 604800  # 3600 * 24 * 7
+expire_password_reset = 86400  # 3600 * 24
+expire_account_deletion = 86400  # 3600 * 24
 
 [api.security]
 # Authifier Shield API key
@@ -56,18 +68,35 @@ voso_legacy_token = ""
 trust_cloudflare = false
 # easypwned endpoint
 easypwned = ""
+# Tenor API Key
+tenor_key = ""
 
 [api.security.captcha]
 # hCaptcha configuration
 hcaptcha_key = ""
 hcaptcha_sitekey = ""
 
+[api.security.shield]
+host = ""
+key = ""
+
 [api.workers]
 # Maximum concurrent connections (to proxy server)
 max_concurrent_connections = 50
 
-[api.users]
+[api.livekit]
+# How long to ring devices for when calling in dms/groups, in seconds
+call_ring_duration = 30
 
+[api.audit_logs]
+# How long audit log entries last before being removed, in seconds
+expires_after = 2592000  # 30d
+
+[api.livekit.nodes]
+
+[api.users]
+# Minimum allowed length of usernames
+min_username_length = 2
 
 [pushd]
 # this changes the names of the queues to not overlap 
@@ -79,12 +108,18 @@ production = true
 # Increasing this will resolve mentions faster, but will consume more memory while resolving.
 mass_mention_chunk_size = 200
 
+# How long pushd will cache resolved names for rendered message notifications.
+# Increasing this will result in lower database usage, but may result in a situation where a user/channel/role name changes 
+# and the notifications still resolve to the old name.
+render_cache_time = 60
+
 # 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
+dm_call_queue = "notifications.ingest.dm_call"   # direct message voice call
 generic_queue = "notifications.ingest.generic"           # generic messages (title + body)
 ack_queue = "notifications.process.ack"                  # updates badges for apple devices
 
@@ -114,6 +149,8 @@ pkcs8 = ""
 key_id = ""
 team_id = ""
 
+[january]
+blocked_domains = []
 
 [files]
 # Encryption key for stored files
@@ -210,6 +247,10 @@ new_user_hours = 72
 # (should be greater than any one file upload limit)
 body_limit_size = 20_000_000
 
+# If any userids are entered here, only those users will be able to create servers.
+# Leave empty to allow all users to create servers
+restrict_server_creation = []
+
 [features.limits.new_user]
 # Limits imposed on new users
 
@@ -228,6 +269,18 @@ message_attachments = 5
 # Maximum number of servers the user can create/join
 servers = 50
 
+# Maximum audio frequency (Hz) in voice calls
+voice_quality = 16000
+
+# Whether the user can use video streams in voice calls
+video = true
+
+# Maximum resolution (width, height) of video streams in voice calls
+video_resolution = [1080, 720]
+
+# Minimum and maximum aspect ratio of video streams in voice calls
+video_aspect_ratio = [0.3, 2.5]
+
 [features.limits.new_user.file_upload_size_limit]
 # Maximum file size limits (in bytes)
 attachments = 20_000_000
@@ -255,6 +308,18 @@ message_attachments = 5
 # Maximum number of servers the user can create/join
 servers = 100
 
+# Maximum audio frequency (Hz) in voice calls
+voice_quality = 16000
+
+# Whether the user can use video streams in voice calls
+video = true
+
+# Maximum resolution (width, height) of video streams in voice calls
+video_resolution = [1280, 720]
+
+# Minimum and maximum aspect ratio of video streams in voice calls
+video_aspect_ratio = [0.3, 2.5]
+
 [features.limits.default.file_upload_size_limit]
 # Maximum file size limits (in bytes)
 attachments = 20_000_000
@@ -269,11 +334,19 @@ emojis = 500_000
 # default: 5
 process_message_delay_limit = 5
 
+[features.legal_links]
+# URLs for legal documents
+terms_of_service = ""
+privacy_policy = ""
+guidelines = ""
+
 [sentry]
 # Configuration for Sentry error reporting
 api = ""
 events = ""
+voice_ingress = ""
 files = ""
 proxy = ""
 pushd = ""
 crond = ""
+gifbox = ""

crates/core/config/src/lib.rs

@@ -1,9 +1,10 @@
-use std::collections::HashMap;
+#[cfg(feature = "test")]
+use std::sync::OnceLock;
+use std::{collections::HashMap, path::Path, sync::LazyLock};
 
 use cached::proc_macro::cached;
-use config::{Config, File, FileFormat};
+use config::{Config, Environment, File, FileFormat};
 use futures_locks::RwLock;
-use once_cell::sync::Lazy;
 use serde::Deserialize;
 
 #[cfg(feature = "sentry")]
@@ -66,13 +67,28 @@ static CONFIG_SEARCH_PATHS: [&str; 3] = [
 static TEST_OVERRIDE_PATH: &str = "Revolt.test-overrides.toml";
 
 /// Configuration builder
-static CONFIG_BUILDER: Lazy<RwLock<Config>> = Lazy::new(|| {
+static CONFIG_BUILDER: LazyLock<RwLock<Config>> = LazyLock::new(|| {
     RwLock::new({
         let mut builder = Config::builder().add_source(File::from_str(
             include_str!("../Revolt.toml"),
             FileFormat::Toml,
         ));
 
+        let cwd = std::env::current_dir().unwrap();
+        let mut cwd: Option<&Path> = Some(&cwd);
+
+        while let Some(path) = cwd {
+            for config_path in CONFIG_SEARCH_PATHS {
+                let config_path = path.join(config_path);
+                if config_path.exists() {
+                    builder = builder
+                        .add_source(File::new(config_path.to_str().unwrap(), FileFormat::Toml));
+                }
+            }
+
+            cwd = path.parent();
+        }
+
         if std::env::var("TEST_DB").is_ok() {
             builder = builder.add_source(File::from_str(
                 include_str!("../Revolt.test.toml"),
@@ -94,11 +110,7 @@ static CONFIG_BUILDER: Lazy<RwLock<Config>> = Lazy::new(|| {
             }
         }
 
-        for path in CONFIG_SEARCH_PATHS {
-            if std::path::Path::new(path).exists() {
-                builder = builder.add_source(File::new(path, FileFormat::Toml));
-            }
-        }
+        builder = builder.add_source(Environment::with_prefix("REVOLT").separator("__"));
 
         builder.build().unwrap()
     })
@@ -108,6 +120,12 @@ static CONFIG_BUILDER: Lazy<RwLock<Config>> = Lazy::new(|| {
 pub struct Database {
     pub mongodb: String,
     pub redis: String,
+    pub redis_pubsub: Option<String>,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct RabbitQueues {
+    pub acks: String,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -116,6 +134,8 @@ pub struct Rabbit {
     pub port: u16,
     pub username: String,
     pub password: String,
+    pub default_exchange: String,
+    pub queues: RabbitQueues,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -125,8 +145,7 @@ pub struct Hosts {
     pub events: String,
     pub autumn: String,
     pub january: String,
-    pub voso_legacy: String,
-    pub voso_legacy_ws: String,
+    pub livekit: HashMap<String, String>,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -144,6 +163,18 @@ pub struct ApiSmtp {
     pub port: Option<i32>,
     pub use_tls: Option<bool>,
     pub use_starttls: Option<bool>,
+    pub expiry: EmailExpiry,
+}
+
+/// Email expiration config
+#[derive(Deserialize, Debug, Clone)]
+pub struct EmailExpiry {
+    /// How long email verification codes should last for (in seconds)
+    pub expire_verification: i64,
+    /// How long password reset codes should last for (in seconds)
+    pub expire_password_reset: i64,
+    /// How long account deletion codes should last for (in seconds)
+    pub expire_account_deletion: i64,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -183,13 +214,20 @@ pub struct ApiSecurityCaptcha {
     pub hcaptcha_sitekey: String,
 }
 
+#[derive(Deserialize, Debug, Clone)]
+pub struct ApiSecurityShield {
+    pub host: String,
+    pub key: String,
+}
+
 #[derive(Deserialize, Debug, Clone)]
 pub struct ApiSecurity {
-    pub authifier_shield_key: String,
+    pub shield: ApiSecurityShield,
     pub voso_legacy_token: String,
     pub captcha: ApiSecurityCaptcha,
     pub trust_cloudflare: bool,
     pub easypwned: String,
+    pub tenor_key: String,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -197,9 +235,35 @@ pub struct ApiWorkers {
     pub max_concurrent_connections: usize,
 }
 
+#[derive(Deserialize, Debug, Clone)]
+pub struct ApiLiveKit {
+    pub call_ring_duration: usize,
+    pub nodes: HashMap<String, LiveKitNode>,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct LiveKitNode {
+    pub url: String,
+    pub lat: f64,
+    pub lon: f64,
+    pub key: String,
+    pub secret: String,
+
+    // whether to hide the node in the nodes list
+    #[serde(default)]
+    pub private: bool,
+}
+
 #[derive(Deserialize, Debug, Clone)]
 pub struct ApiUsers {
     pub early_adopter_cutoff: Option<u64>,
+    pub min_username_length: usize,
+}
+
+#[derive(Deserialize, Debug, Clone)]
+pub struct ApiAuditLogs {
+    /// How long audit log entries last before being removed, in seconds
+    pub expires_after: u64,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -208,7 +272,9 @@ pub struct Api {
     pub smtp: ApiSmtp,
     pub security: ApiSecurity,
     pub workers: ApiWorkers,
+    pub livekit: ApiLiveKit,
     pub users: ApiUsers,
+    pub audit_logs: ApiAuditLogs,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -216,10 +282,12 @@ pub struct Pushd {
     pub production: bool,
     pub exchange: String,
     pub mass_mention_chunk_size: usize,
+    pub render_cache_time: usize,
 
     // Queues
     pub message_queue: String,
     pub mass_mention_queue: String,
+    pub dm_call_queue: String,
     pub fr_accepted_queue: String,
     pub fr_received_queue: String,
     pub generic_queue: String,
@@ -250,6 +318,10 @@ impl Pushd {
         self.get_routing_key(self.mass_mention_queue.clone())
     }
 
+    pub fn get_dm_call_routing_key(&self) -> String {
+        self.get_routing_key(self.dm_call_queue.clone())
+    }
+
     pub fn get_fr_accepted_routing_key(&self) -> String {
         self.get_routing_key(self.fr_accepted_queue.clone())
     }
@@ -263,6 +335,11 @@ impl Pushd {
     }
 }
 
+#[derive(Deserialize, Debug, Clone)]
+pub struct January {
+    pub blocked_domains: Vec<String>,
+}
+
 #[derive(Deserialize, Debug, Clone)]
 pub struct FilesLimit {
     pub min_file_size: usize,
@@ -307,6 +384,8 @@ pub struct GlobalLimits {
     pub new_user_hours: usize,
 
     pub body_limit_size: usize,
+
+    pub restrict_server_creation: Vec<String>,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -317,6 +396,10 @@ pub struct FeaturesLimits {
     pub message_length: usize,
     pub message_attachments: usize,
     pub servers: usize,
+    pub voice_quality: u32,
+    pub video: bool,
+    pub video_resolution: [u32; 2],
+    pub video_aspect_ratio: [f32; 2],
 
     pub file_upload_size_limit: HashMap<String, usize>,
 }
@@ -332,6 +415,16 @@ pub struct FeaturesLimitsCollection {
     pub roles: HashMap<String, FeaturesLimits>,
 }
 
+#[derive(Deserialize, Debug, Clone)]
+pub struct LegalLinks {
+    /// Terms of Service URL
+    pub terms_of_service: String,
+    /// Privacy Policy URL
+    pub privacy_policy: String,
+    /// Guidelines URL
+    pub guidelines: String,
+}
+
 #[derive(Deserialize, Debug, Clone)]
 pub struct FeaturesAdvanced {
     #[serde(default)]
@@ -349,6 +442,7 @@ impl Default for FeaturesAdvanced {
 #[derive(Deserialize, Debug, Clone)]
 pub struct Features {
     pub limits: FeaturesLimitsCollection,
+    pub legal_links: LegalLinks,
     pub webhooks_enabled: bool,
     pub mass_mentions_send_notifications: bool,
     pub mass_mentions_enabled: bool,
@@ -361,10 +455,12 @@ pub struct Features {
 pub struct Sentry {
     pub api: String,
     pub events: String,
+    pub voice_ingress: String,
     pub files: String,
     pub proxy: String,
     pub pushd: String,
     pub crond: String,
+    pub gifbox: String,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -374,10 +470,13 @@ pub struct Settings {
     pub hosts: Hosts,
     pub api: Api,
     pub pushd: Pushd,
+    pub january: January,
     pub files: Files,
     pub features: Features,
     pub sentry: Sentry,
     pub production: bool,
+    pub environment: String,
+    pub disable_events_dont_use: bool,
 }
 
 impl Settings {
@@ -403,23 +502,52 @@ pub async fn read() -> Config {
     CONFIG_BUILDER.read().await.clone()
 }
 
-#[cached(time = 30)]
-pub async fn config() -> Settings {
+pub async fn config_no_cache() -> 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() {
+    if std::env::var("REDIS_URI").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") {
+    if config.hosts.api.contains("https")
+        && (config.hosts.api.contains("revolt.chat") || config.hosts.api.contains("stoat.chat"))
+    {
         config.production = true;
     }
 
     config
 }
 
+#[cached(time = 30)]
+pub async fn config() -> Settings {
+    #[cfg(feature = "test")]
+    if let Some(overwrites) = CONFIG_OVERWRITES.get() {
+        return overwrites.clone();
+    }
+
+    config_no_cache().await
+}
+
+#[cfg(feature = "test")]
+static CONFIG_OVERWRITES: OnceLock<Settings> = OnceLock::new();
+
+/// Modify the config values for a test, this can only be called once
+///
+/// This will also fail if two or more tests are running in the same process and both try to modify the config,
+/// This could happen if tests where run under `cargo test` instead of `nextest`.
+#[cfg(feature = "test")]
+pub async fn overwrite_config(f: impl FnOnce(&mut Settings)) {
+    let mut config = config_no_cache().await;
+
+    f(&mut config);
+
+    CONFIG_OVERWRITES.set(config).expect(
+        "Cannot overwrite config multiple times, make sure you are running tests through nextest.",
+    );
+}
+
 /// Configure logging and common Rust variables
 #[cfg(feature = "sentry")]
 pub async fn setup_logging(release: &'static str, dsn: String) -> Option<sentry::ClientInitGuard> {
@@ -465,7 +593,7 @@ macro_rules! configure {
 mod tests {
     use crate::init;
 
-    #[async_std::test]
+    #[tokio::test]
     async fn it_works() {
         init().await;
     }

crates/core/database/Cargo.toml

@@ -1,98 +1,113 @@
 [package]
 name = "revolt-database"
-version = "0.8.8"
+version = "0.13.7"
 edition = "2021"
 license = "AGPL-3.0-or-later"
 authors = ["Paul Makles <me@insrt.uk>"]
 description = "Revolt Backend: Database Implementation"
+repository = "https://github.com/stoatchat/stoatchat"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [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"]
-axum-impl = ["axum"]
+tokio-runtime = ["tokio"]
+rocket-impl = [
+    "rocket",
+    "schemars",
+    "revolt_okapi",
+    "revolt_rocket_okapi",
+]
+axum-impl = ["axum", "revolt-result/axum", "utoipa"]
 redis-is-patched = ["revolt-presence/redis-is-patched"]
+voice = ["livekit-api", "livekit-protocol", "livekit-runtime"]
 
 # Default Features
-default = ["mongodb", "async-std-runtime", "tasks"]
+default = ["mongodb", "tokio-runtime", "tasks"]
 
 [dependencies]
 # Core
-revolt-config = { version = "0.8.8", path = "../config", features = [
-    "report-macros",
-] }
-revolt-result = { version = "0.8.8", path = "../result" }
-revolt-models = { version = "0.8.8", path = "../models", features = [
-    "validator",
-] }
-revolt-presence = { version = "0.8.8", path = "../presence" }
-revolt-permissions = { version = "0.8.8", path = "../permissions", features = [
-    "serde",
-    "bson",
-] }
-revolt-parser = { version = "0.8.8", path = "../parser" }
+revolt-config = { workspace = true, features = ["report-macros"] }
+revolt-result = { workspace = true }
+revolt-models = { workspace = true, features = ["validator"] }
+revolt-presence = { workspace = true }
+revolt-permissions = { workspace = true, features = ["serde", "bson"] }
+revolt-parser = { workspace = true }
+revolt-coalesced = { workspace = true }
 
 # Utility
-log = "0.4"
-lru = "0.11.0"
-rand = "0.8.5"
-ulid = "1.0.0"
-nanoid = "0.4.0"
-base64 = "0.21.3"
-once_cell = "1.17"
-indexmap = "1.9.1"
-decancer = "1.6.2"
-deadqueue = "0.2.4"
-linkify = { optional = true, version = "0.8.1" }
-url-escape = { optional = true, version = "0.1.1" }
-validator = { version = "0.16", features = ["derive"] }
-isahc = { optional = true, version = "1.7", features = ["json"] }
+log = { workspace = true }
+lru = { workspace = true }
+rand = { workspace = true }
+ulid = { workspace = true }
+nanoid = { workspace = true }
+base64 = { workspace = true }
+once_cell = { workspace = true }
+indexmap = { workspace = true }
+decancer = { workspace = true }
+deadqueue = { workspace = true }
+linkify = { workspace = true, optional = true }
+url-escape = { workspace = true, optional = true }
+validator = { workspace = true, features = ["derive"] }
+isahc = { workspace = true, features = ["json"], optional = true }
+base32 = { workspace = true }
+sha1 = { workspace = true }
 
 # Serialisation
-serde_json = "1"
-revolt_optional_struct = "0.2.0"
-serde = { version = "1", features = ["derive"] }
-iso8601-timestamp = { version = "0.2.10", features = ["serde", "bson"] }
+serde_json = { workspace = true }
+revolt_optional_struct = { workspace = true }
+serde = { workspace = true }
+iso8601-timestamp = { workspace = true, features = ["serde", "bson"] }
 
 # Events
-redis-kiss = { version = "0.1.4" }
+redis-kiss = { workspace = true, default-features = false, features = ["tokio-runtime"] }
 
 # Database
-bson = { optional = true, version = "2.1.0" }
-mongodb = { optional = true, version = "3.1.0" }
+bson = { workspace = true, optional = true }
+mongodb = { workspace = true, optional = true }
 
 # Database Migration
-unicode-segmentation = "1.10.1"
-regex = "1"
+unicode-segmentation = { workspace = true }
+regex = { workspace = true }
 
 # Async Language Features
-futures = "0.3.19"
-async-lock = "2.8.0"
-async-trait = "0.1.51"
-async-recursion = "1.0.4"
+futures = { workspace = true }
+async-lock = { workspace = true }
+async-trait = { workspace = true }
+async-recursion = { workspace = true }
 
 # Async
-async-std = { version = "1.8.0", features = ["attributes"], optional = true }
+tokio = { workspace = true, optional = true }
 
 # Axum Impl
-axum = { version = "0.7.5", optional = true }
+axum = { workspace = true, optional = true }
+utoipa = { workspace = true, features = ["axum_extras"], optional = true }
 
 # Rocket Impl
-schemars = { version = "0.8.8", optional = true }
-rocket = { version = "0.5.1", default-features = false, features = [
-    "json",
-], optional = true }
-revolt_okapi = { version = "0.9.1", optional = true }
-revolt_rocket_okapi = { version = "0.10.0", optional = true }
-
-# Authifier
-authifier = { version = "1.0.15" }
+schemars = { workspace = true, optional = true }
+rocket = { workspace = true, features = ["json"], optional = true }
+revolt_okapi = { workspace = true, optional = true }
+revolt_rocket_okapi = { workspace = true, optional = true }
 
 # RabbitMQ
-amqprs = { version = "1.7.0" }
+lapin = { workspace = true, features = ["tokio"] }
+
+# Voice
+livekit-api = { workspace = true, features = ["rustls-tls-native-roots"], optional = true }
+livekit-protocol = { workspace = true, optional = true }
+livekit-runtime = { workspace = true, features = ["tokio"], optional = true }
+
+# Security
+totp-lite = { workspace = true }
+rust-argon2 = { workspace = true }
+
+# Email
+lettre = { workspace = true }
+handlebars = { workspace = true }
+
+# Web Requests
+reqwest = { workspace = true, features = ["json", "form"] }

crates/core/database/assets/revolt_source_list.txt

@@ -0,0 +1,555 @@
+this is an assorted list of known disposable email providers
+
+#region nobody will ever have an email @example.com so we can safely block it
+----
+example.com
+
+#region list provided by michenriksen at https://gist.github.com/michenriksen/8710649
+----
+0815.ru
+0wnd.net
+0wnd.org
+10minutemail.co.za
+10minutemail.com
+123-m.com
+1fsdfdsfsdf.tk
+1pad.de
+20minutemail.com
+21cn.com
+2fdgdfgdfgdf.tk
+2prong.com
+30minutemail.com
+33mail.com
+3trtretgfrfe.tk
+4gfdsgfdgfd.tk
+4warding.com
+5ghgfhfghfgh.tk
+6hjgjhgkilkj.tk
+6paq.com
+7tags.com
+9ox.net
+a-bc.net
+agedmail.com
+ama-trade.de
+amilegit.com
+amiri.net
+amiriindustries.com
+anonmails.de
+anonymbox.com
+antichef.com
+antichef.net
+antireg.ru
+antispam.de
+antispammail.de
+armyspy.com
+artman-conception.com
+azmeil.tk
+baxomale.ht.cx
+beefmilk.com
+bigstring.com
+binkmail.com
+bio-muesli.net
+bobmail.info
+bodhi.lawlita.com
+bofthew.com
+bootybay.de
+boun.cr
+bouncr.com
+breakthru.com
+brefmail.com
+bsnow.net
+bspamfree.org
+bugmenot.com
+bund.us
+burstmail.info
+buymoreplays.com
+byom.de
+c2.hu
+casualdx.com
+cek.pm
+centermail.com
+centermail.net
+chammy.info
+childsavetrust.org
+chogmail.com
+choicemail1.com
+clixser.com
+cmail.net
+cmail.org
+coldemail.info
+cool.fr.nf
+courriel.fr.nf
+courrieltemporaire.com
+crapmail.org
+cust.in
+cuvox.de
+d3p.dk
+dacoolest.com
+dandikmail.com
+dayrep.com
+dcemail.com
+deadaddress.com
+deadspam.com
+delikkt.de
+despam.it
+despammed.com
+devnullmail.com
+dfgh.net
+digitalsanctuary.com
+dingbone.com
+disposableaddress.com
+disposableemailaddresses.com
+disposableinbox.com
+dispose.it
+dispostable.com
+dodgeit.com
+dodgit.com
+donemail.ru
+dontreg.com
+dontsendmespam.de
+drdrb.net
+dump-email.info
+dumpandjunk.com
+dumpyemail.com
+e-mail.com
+e-mail.org
+e4ward.com
+easytrashmail.com
+einmalmail.de
+einrot.com
+eintagsmail.de
+emailgo.de
+emailias.com
+emaillime.com
+emailsensei.com
+emailtemporanea.com
+emailtemporanea.net
+emailtemporar.ro
+emailtemporario.com.br
+emailthe.net
+emailtmp.com
+emailwarden.com
+emailx.at.hm
+emailxfer.com
+emeil.in
+emeil.ir
+emz.net
+ero-tube.org
+evopo.com
+explodemail.com
+eyepaste.com
+fakeinbox.com
+fakeinformation.com
+fansworldwide.de
+fantasymail.de
+fightallspam.com
+filzmail.com
+fivemail.de
+fleckens.hu
+frapmail.com
+friendlymail.co.uk
+fuckingduh.com
+fudgerub.com
+fyii.de
+garliclife.com
+gehensiemirnichtaufdensack.de
+get2mail.fr
+getairmail.com
+getmails.eu
+getonemail.com
+giantmail.de
+girlsundertheinfluence.com
+gishpuppy.com
+gmial.com
+goemailgo.com
+gotmail.net
+gotmail.org
+gotti.otherinbox.com
+great-host.in
+greensloth.com
+grr.la
+gsrv.co.uk
+guerillamail.biz
+guerillamail.com
+guerrillamail.biz
+guerrillamail.com
+guerrillamail.de
+guerrillamail.info
+guerrillamail.net
+guerrillamail.org
+guerrillamailblock.com
+gustr.com
+harakirimail.com
+hat-geld.de
+hatespam.org
+herp.in
+hidemail.de
+hidzz.com
+hmamail.com
+hopemail.biz
+ieh-mail.de
+ikbenspamvrij.nl
+imails.info
+inbax.tk
+inbox.si
+inboxalias.com
+inboxclean.com
+inboxclean.org
+instant-mail.de
+ip6.li
+irish2me.com
+iwi.net
+jetable.com
+jetable.fr.nf
+jetable.net
+jetable.org
+jnxjn.com
+jourrapide.com
+jsrsolutions.com
+kasmail.com
+kaspop.com
+killmail.com
+killmail.net
+klassmaster.com
+klzlk.com
+koszmail.pl
+kurzepost.de
+lawlita.com
+letthemeatspam.com
+lhsdv.com
+lifebyfood.com
+link2mail.net
+litedrop.com
+lol.ovpn.to
+lolfreak.net
+lookugly.com
+lortemail.dk
+lr78.com
+lroid.com
+lukop.dk
+m21.cc
+mail-filter.com
+mail-temporaire.fr
+mail.mezimages.net
+mail1a.de
+mail21.cc
+mail2rss.org
+mail333.com
+mailbidon.com
+mailbiz.biz
+mailblocks.com
+mailbucket.org
+mailcat.biz
+mailcatch.com
+mailde.de
+mailde.info
+maildrop.cc
+maileimer.de
+mailexpire.com
+mailfa.tk
+mailforspam.com
+mailfreeonline.com
+mailguard.me
+mailin8r.com
+mailinater.com
+mailinator.com
+mailinator.net
+mailinator.org
+mailinator2.com
+mailincubator.com
+mailismagic.com
+mailme.lv
+mailme24.com
+mailmetrash.com
+mailmoat.com
+mailms.com
+mailnesia.com
+mailnull.com
+mailorg.org
+mailpick.biz
+mailrock.biz
+mailscrap.com
+mailshell.com
+mailsiphon.com
+mailtemp.info
+mailtome.de
+mailtothis.com
+mailtrash.net
+mailtv.net
+mailtv.tv
+mailzilla.com
+makemetheking.com
+manybrain.com
+mbx.cc
+mega.zik.dj
+meinspamschutz.de
+meltmail.com
+messagebeamer.de
+mezimages.net
+ministry-of-silly-walks.de
+mintemail.com
+misterpinball.de
+moncourrier.fr.nf
+monemail.fr.nf
+monmail.fr.nf
+monumentmail.com
+mt2009.com
+mt2014.com
+mycleaninbox.net
+mymail-in.net
+mypacks.net
+mypartyclip.de
+myphantomemail.com
+mysamp.de
+mytempemail.com
+mytempmail.com
+mytrashmail.com
+nabuma.com
+neomailbox.com
+nepwk.com
+nervmich.net
+nervtmich.net
+netmails.com
+netmails.net
+neverbox.com
+nice-4u.com
+nincsmail.hu
+nnh.com
+no-spam.ws
+noblepioneer.com
+nomail.pw
+nomail.xl.cx
+nomail2me.com
+nomorespamemails.com
+nospam.ze.tc
+nospam4.us
+nospamfor.us
+nospammail.net
+notmailinator.com
+nowhere.org
+nowmymail.com
+nurfuerspam.de
+nus.edu.sg
+objectmail.com
+obobbo.com
+odnorazovoe.ru
+oneoffemail.com
+onewaymail.com
+onlatedotcom.info
+online.ms
+ordinaryamerican.net
+otherinbox.com
+ovpn.to
+owlpic.com
+pancakemail.com
+pcusers.otherinbox.com
+pjjkp.com
+plexolan.de
+poczta.onet.pl
+politikerclub.de
+poofy.org
+pookmail.com
+privacy.net
+privatdemail.net
+proxymail.eu
+prtnx.com
+putthisinyourspamdatabase.com
+putthisinyourspamdatabase.com
+quickinbox.com
+rcpt.at
+reallymymail.com
+realtyalerts.ca
+recode.me
+recursor.net
+reliable-mail.com
+rhyta.com
+rmqkr.net
+royal.net
+rtrtr.com
+s0ny.net
+safersignup.de
+safetymail.info
+safetypost.de
+saynotospams.com
+schafmail.de
+schrott-email.de
+secretemail.de
+secure-mail.biz
+senseless-entertainment.com
+services391.com
+sharklasers.com
+shieldemail.com
+shiftmail.com
+shitmail.me
+shitware.nl
+shmeriously.com
+shortmail.net
+sinnlos-mail.de
+slapsfromlastnight.com
+slaskpost.se
+smashmail.de
+smellfear.com
+snakemail.com
+sneakemail.com
+sneakmail.de
+snkmail.com
+sofimail.com
+solvemail.info
+sogetthis.com
+soodonims.com
+spam4.me
+spamail.de
+spamarrest.com
+spambob.net
+spambog.ru
+spambox.us
+spamcannon.com
+spamcannon.net
+spamcon.org
+spamcorptastic.com
+spamcowboy.com
+spamcowboy.net
+spamcowboy.org
+spamday.com
+spamex.com
+spamfree.eu
+spamfree24.com
+spamfree24.de
+spamfree24.org
+spamgoes.in
+spamgourmet.com
+spamgourmet.net
+spamgourmet.org
+spamherelots.com
+spamherelots.com
+spamhereplease.com
+spamhereplease.com
+spamhole.com
+spamify.com
+spaml.de
+spammotel.com
+spamobox.com
+spamslicer.com
+spamspot.com
+spamthis.co.uk
+spamtroll.net
+speed.1s.fr
+spoofmail.de
+stuffmail.de
+super-auswahl.de
+supergreatmail.com
+supermailer.jp
+superrito.com
+superstachel.de
+suremail.info
+talkinator.com
+teewars.org
+teleworm.com
+teleworm.us
+temp-mail.org
+temp-mail.ru
+tempe-mail.com
+tempemail.co.za
+tempemail.com
+tempemail.net
+tempemail.net
+tempinbox.co.uk
+tempinbox.com
+tempmail.eu
+tempmaildemo.com
+tempmailer.com
+tempmailer.de
+tempomail.fr
+temporaryemail.net
+temporaryforwarding.com
+temporaryinbox.com
+temporarymailaddress.com
+tempthe.net
+thankyou2010.com
+thc.st
+thelimestones.com
+thisisnotmyrealemail.com
+thismail.net
+throwawayemailaddress.com
+tilien.com
+tittbit.in
+tizi.com
+tmailinator.com
+toomail.biz
+topranklist.de
+tradermail.info
+trash-mail.at
+trash-mail.com
+trash-mail.de
+trash2009.com
+trashdevil.com
+trashemail.de
+trashmail.at
+trashmail.com
+trashmail.de
+trashmail.me
+trashmail.net
+trashmail.org
+trashymail.com
+trialmail.de
+trillianpro.com
+twinmail.de
+tyldd.com
+uggsrock.com
+umail.net
+uroid.com
+us.af
+venompen.com
+veryrealemail.com
+viditag.com
+viralplays.com
+vpn.st
+vsimcard.com
+vubby.com
+wasteland.rfc822.org
+webemail.me
+weg-werf-email.de
+wegwerf-emails.de
+wegwerfadresse.de
+wegwerfemail.com
+wegwerfemail.de
+wegwerfmail.de
+wegwerfmail.info
+wegwerfmail.net
+wegwerfmail.org
+wh4f.org
+whyspam.me
+willhackforfood.biz
+willselfdestruct.com
+winemaven.info
+wronghead.com
+www.e4ward.com
+www.mailinator.com
+wwwnew.eu
+x.ip6.li
+xagloo.com
+xemaps.com
+xents.com
+xmaily.com
+xoxy.net
+yep.it
+yogamaven.com
+yopmail.com
+yopmail.fr
+yopmail.net
+yourdomain.com
+yuurok.com
+z1p.biz
+za.com
+zehnminuten.de
+zehnminutenmail.de
+zippymail.info
+zoemail.net
+zomg.info
+
+#region public emails provided by mail.tm
+----
+trythe.net
+leadwizzer.com
+metalunits.com
+scpulse.com

crates/core/database/fixtures/server_with_roles.json

@@ -47,6 +47,7 @@
     ],
     "roles": {
       "__ID:5__": {
+        "_id": "__ID:5__",
         "name": "Moderator",
         "permissions": {
           "a": 545270208,
@@ -55,6 +56,7 @@
         "rank": 1
       },
       "__ID:6__": {
+        "_id": "__ID:6__",
         "name": "Owner",
         "permissions": {
           "a": 0,

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

@@ -1,30 +1,79 @@
 use std::collections::HashSet;
+use std::sync::Arc;
 
 use crate::events::rabbit::*;
 use crate::User;
-use amqprs::channel::BasicPublishArguments;
-use amqprs::{channel::Channel, connection::Connection, error::Error as AMQPError};
-use amqprs::{BasicProperties, FieldTable};
+use lapin::{
+    options::BasicPublishOptions,
+    protocol::basic::AMQPProperties,
+    types::{AMQPValue, FieldTable},
+    Channel, Connection, ConnectionProperties, Error as AMQPError,
+};
 use revolt_models::v0::PushNotification;
 use revolt_presence::filter_online;
+use revolt_result::Result;
 
 use serde_json::to_string;
 
 #[derive(Clone)]
 pub struct AMQP {
+    friend_request_accepted: Arc<Channel>,
+    friend_request_received: Arc<Channel>,
+    generic_message: Arc<Channel>,
+    message_sent: Arc<Channel>,
+    mass_mention_message_sent: Arc<Channel>,
+    ack_notification_message: Arc<Channel>,
+    dm_call_updated: Arc<Channel>,
+    process_ack: Arc<Channel>,
     #[allow(unused)]
-    connection: Connection,
-    channel: Channel,
+    connection: Arc<Connection>,
 }
 
 impl AMQP {
-    pub fn new(connection: Connection, channel: Channel) -> AMQP {
-        AMQP {
+    pub async fn new(connection: Arc<Connection>) -> Self {
+        Self {
+            friend_request_accepted: Self::create_channel(&connection).await,
+            friend_request_received: Self::create_channel(&connection).await,
+            generic_message: Self::create_channel(&connection).await,
+            message_sent: Self::create_channel(&connection).await,
+            mass_mention_message_sent: Self::create_channel(&connection).await,
+            ack_notification_message: Self::create_channel(&connection).await,
+            dm_call_updated: Self::create_channel(&connection).await,
+            process_ack: Self::create_channel(&connection).await,
             connection,
-            channel,
         }
     }
 
+    pub async fn new_auto() -> Self {
+        let config = revolt_config::config().await;
+
+        let connection = Arc::new(
+            Connection::connect(
+                &format!(
+                    "amqp://{}:{}@{}:{}",
+                    &config.rabbit.username,
+                    &config.rabbit.password,
+                    &config.rabbit.host,
+                    &config.rabbit.port,
+                ),
+                ConnectionProperties::default(),
+            )
+            .await
+            .expect("Failed to connect to RabbitMQ"),
+        );
+
+        Self::new(connection).await
+    }
+
+    async fn create_channel(connection: &Connection) -> Arc<Channel> {
+        Arc::new(
+            connection
+                .create_channel()
+                .await
+                .expect("Failed to create channel"),
+        )
+    }
+
     pub async fn friend_request_accepted(
         &self,
         accepted_request_user: &User,
@@ -42,19 +91,20 @@ impl AMQP {
             config.pushd.get_fr_accepted_routing_key(),
             payload
         );
-        self.channel
+
+        self.friend_request_accepted
             .basic_publish(
-                BasicProperties::default()
-                    .with_content_type("application/json")
-                    .with_persistence(true)
-                    .finish(),
-                payload.into(),
-                BasicPublishArguments::new(
-                    &config.pushd.exchange,
-                    &config.pushd.get_fr_accepted_routing_key(),
-                ),
+                config.pushd.exchange.clone().into(),
+                config.pushd.get_fr_accepted_routing_key().into(),
+                BasicPublishOptions::default(),
+                payload.as_bytes(),
+                AMQPProperties::default()
+                    .with_content_type("application/json".into())
+                    .with_delivery_mode(2),
             )
-            .await
+            .await?;
+
+        Ok(())
     }
 
     pub async fn friend_request_received(
@@ -75,19 +125,19 @@ impl AMQP {
             payload
         );
 
-        self.channel
+        self.friend_request_received
             .basic_publish(
-                BasicProperties::default()
-                    .with_content_type("application/json")
-                    .with_persistence(true)
-                    .finish(),
-                payload.into(),
-                BasicPublishArguments::new(
-                    &config.pushd.exchange,
-                    &config.pushd.get_fr_received_routing_key(),
-                ),
+                config.pushd.exchange.clone().into(),
+                config.pushd.get_fr_received_routing_key().into(),
+                BasicPublishOptions::default(),
+                payload.as_bytes(),
+                AMQPProperties::default()
+                    .with_content_type("application/json".into())
+                    .with_delivery_mode(2),
             )
-            .await
+            .await?;
+
+        Ok(())
     }
 
     pub async fn generic_message(
@@ -112,19 +162,19 @@ impl AMQP {
             payload
         );
 
-        self.channel
+        self.generic_message
             .basic_publish(
-                BasicProperties::default()
-                    .with_content_type("application/json")
-                    .with_persistence(true)
-                    .finish(),
-                payload.into(),
-                BasicPublishArguments::new(
-                    &config.pushd.exchange,
-                    &config.pushd.get_generic_routing_key(),
-                ),
+                config.pushd.exchange.clone().into(),
+                config.pushd.get_generic_routing_key().into(),
+                BasicPublishOptions::default(),
+                payload.as_bytes(),
+                AMQPProperties::default()
+                    .with_content_type("application/json".into())
+                    .with_delivery_mode(2),
             )
-            .await
+            .await?;
+
+        Ok(())
     }
 
     pub async fn message_sent(
@@ -155,19 +205,19 @@ impl AMQP {
             payload
         );
 
-        self.channel
+        self.message_sent
             .basic_publish(
-                BasicProperties::default()
-                    .with_content_type("application/json")
-                    .with_persistence(true)
-                    .finish(),
-                payload.into(),
-                BasicPublishArguments::new(
-                    &config.pushd.exchange,
-                    &config.pushd.get_message_routing_key(),
-                ),
+                config.pushd.exchange.clone().into(),
+                config.pushd.get_message_routing_key().into(),
+                BasicPublishOptions::default(),
+                payload.as_bytes(),
+                AMQPProperties::default()
+                    .with_content_type("application/json".into())
+                    .with_delivery_mode(2),
             )
-            .await
+            .await?;
+
+        Ok(())
     }
 
     pub async fn mass_mention_message_sent(
@@ -190,19 +240,24 @@ impl AMQP {
             routing_key, payload
         );
 
-        self.channel
+        self.mass_mention_message_sent
             .basic_publish(
-                BasicProperties::default()
-                    .with_content_type("application/json")
-                    .with_persistence(true)
-                    .finish(),
-                payload.into(),
-                BasicPublishArguments::new(&config.pushd.exchange, routing_key.as_str()),
+                config.pushd.exchange.clone().into(),
+                routing_key.into(),
+                BasicPublishOptions::default(),
+                payload.as_bytes(),
+                AMQPProperties::default()
+                    .with_content_type("application/json".into())
+                    .with_delivery_mode(2),
             )
-            .await
+            .await?;
+
+        Ok(())
     }
 
-    pub async fn ack_message(
+    /// # Sends an ack to pushd to update badges on iPhones.
+    /// Not to be confused with the process_ack function, which handles sending all acks to crond for processing.
+    pub async fn ack_notification_message(
         &self,
         user_id: String,
         channel_id: String,
@@ -222,22 +277,106 @@ impl AMQP {
             config.pushd.ack_queue, payload
         );
 
-        let mut headers = FieldTable::new();
+        let mut headers = FieldTable::default();
         headers.insert(
-            "x-deduplication-header".try_into().unwrap(),
-            format!("{}-{}", &user_id, &channel_id).into(),
+            "x-deduplication-header".into(),
+            AMQPValue::LongString(format!("{}-{}", &user_id, &channel_id).into()),
         );
 
-        self.channel
+        self.ack_notification_message
             .basic_publish(
-                BasicProperties::default()
-                    .with_content_type("application/json")
-                    .with_persistence(true)
-                    //.with_headers(headers)
-                    .finish(),
-                payload.into(),
-                BasicPublishArguments::new(&config.pushd.exchange, &config.pushd.ack_queue),
+                config.pushd.exchange.clone().into(),
+                config.pushd.ack_queue.into(),
+                BasicPublishOptions::default(),
+                payload.as_bytes(),
+                AMQPProperties::default()
+                    .with_content_type("application/json".into())
+                    .with_delivery_mode(2),
             )
-            .await
+            .await?;
+
+        Ok(())
+    }
+
+    /// # DM Call Update
+    /// Used to send an update about a DM call, eg. start or end of a call.
+    /// Recipients can be used to narrow the scope of recipients, otherwise all recipients will be notified.
+    /// `ended` refers to the ringing period, not necessarily the call itself.
+    pub async fn dm_call_updated(
+        &self,
+        initiator_id: &str,
+        channel_id: &str,
+        started_at: Option<&str>,
+        ended: bool,
+        recipients: Option<Vec<String>>,
+    ) -> Result<(), AMQPError> {
+        let config = revolt_config::config().await;
+
+        let payload = InternalDmCallPayload {
+            payload: DmCallPayload {
+                initiator_id: initiator_id.to_string(),
+                channel_id: channel_id.to_string(),
+                started_at: started_at.map(|f| f.to_string()),
+                ended,
+            },
+            recipients,
+        };
+        let payload = to_string(&payload).unwrap();
+
+        debug!(
+            "Sending dm call update payload on channel {}: {}",
+            config.pushd.get_dm_call_routing_key(),
+            payload
+        );
+
+        self.dm_call_updated
+            .basic_publish(
+                config.pushd.exchange.clone().into(),
+                config.pushd.get_dm_call_routing_key().into(),
+                BasicPublishOptions::default(),
+                payload.as_bytes(),
+                AMQPProperties::default()
+                    .with_content_type("application/json".into())
+                    .with_delivery_mode(2),
+            )
+            .await?;
+
+        Ok(())
+    }
+
+    /// # Send an ack to crond for processing
+    pub async fn process_ack(
+        &self,
+        user_id: &str,
+        channel_id: Option<&str>,
+        server_id: Option<&str>,
+    ) -> Result<(), AMQPError> {
+        let config = revolt_config::config().await;
+
+        let payload = AckEventPayload {
+            user_id: user_id.to_string(),
+            channel_id: channel_id.map(|value| value.to_string()),
+            server_id: server_id.map(|value| value.to_string()),
+        };
+        let payload = to_string(&payload).unwrap();
+
+        info!(
+            "Sending ack processor event on exchange {}, channel {}: {}",
+            config.rabbit.default_exchange, config.rabbit.queues.acks, payload
+        );
+
+        self.process_ack
+            .basic_publish(
+                config.rabbit.default_exchange.clone().into(),
+                config.rabbit.queues.acks.into(),
+                BasicPublishOptions::default(),
+                payload.as_bytes(),
+                AMQPProperties::default()
+                    .with_content_type("application/json".into())
+                    .with_delivery_mode(2),
+            )
+            .await?;
+
+        Ok(())
     }
 }

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

@@ -2,15 +2,7 @@
 mod mongodb;
 mod reference;
 
-use authifier::config::Captcha;
-use authifier::config::EmailVerificationConfig;
-use authifier::config::PasswordScanning;
-use authifier::config::ResolveIp;
-use authifier::config::SMTPSettings;
-use authifier::config::Shield;
-use authifier::config::Template;
-use authifier::config::Templates;
-use authifier::Authifier;
+
 use rand::Rng;
 use revolt_config::config;
 
@@ -35,7 +27,7 @@ pub enum DatabaseInfo {
 }
 
 /// Database
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub enum Database {
     /// Mock database
     Reference(ReferenceDb),
@@ -69,7 +61,7 @@ impl DatabaseInfo {
                     .await;
 
                     #[cfg(not(feature = "mongodb"))]
-                    return Err("MongoDB not enabled.".to_string())
+                    return Err("MongoDB not enabled.".to_string());
                 } else {
                     DatabaseInfo::Reference.connect().await
                 }
@@ -90,7 +82,7 @@ impl DatabaseInfo {
                         .await;
 
                         #[cfg(not(feature = "mongodb"))]
-                        return Err("MongoDB not enabled.".to_string())
+                        return Err("MongoDB not enabled.".to_string());
                     }
                     _ => unreachable!("must specify REFERENCE or MONGODB"),
                 }
@@ -111,139 +103,3 @@ impl DatabaseInfo {
         }
     }
 }
-
-impl Database {
-    /// Create an Authifier reference
-    pub async fn to_authifier(self) -> Authifier {
-        let config = config().await;
-
-        let mut auth_config = authifier::Config {
-            password_scanning: if config.api.security.easypwned.is_empty() {
-                Default::default()
-            } else {
-                PasswordScanning::EasyPwned {
-                    endpoint: config.api.security.easypwned,
-                }
-            },
-            email_verification: if !config.api.smtp.host.is_empty() {
-                EmailVerificationConfig::Enabled {
-                    smtp: SMTPSettings {
-                        from: config.api.smtp.from_address,
-                        host: config.api.smtp.host,
-                        username: config.api.smtp.username,
-                        password: config.api.smtp.password,
-                        reply_to: Some(
-                            config
-                                .api
-                                .smtp
-                                .reply_to
-                                .unwrap_or("support@revolt.chat".into()),
-                        ),
-                        port: config.api.smtp.port,
-                        use_tls: config.api.smtp.use_tls,
-                        use_starttls: config.api.smtp.use_starttls,
-                    },
-                    expiry: Default::default(),
-                    templates: if config.production {
-                        Templates {
-                            verify: Template {
-                                title: "Verify your Revolt account.".into(),
-                                text: include_str!("../../templates/verify.txt").into(),
-                                url: format!("{}/login/verify/", config.hosts.app),
-                                html: Some(include_str!("../../templates/verify.html").into()),
-                            },
-                            reset: Template {
-                                title: "Reset your Revolt password.".into(),
-                                text: include_str!("../../templates/reset.txt").into(),
-                                url: format!("{}/login/reset/", config.hosts.app),
-                                html: Some(include_str!("../../templates/reset.html").into()),
-                            },
-                            reset_existing: Template {
-                                title: "You already have a Revolt account, reset your password."
-                                    .into(),
-                                text: include_str!("../../templates/reset-existing.txt").into(),
-                                url: format!("{}/login/reset/", config.hosts.app),
-                                html: Some(
-                                    include_str!("../../templates/reset-existing.html").into(),
-                                ),
-                            },
-                            deletion: Template {
-                                title: "Confirm account deletion.".into(),
-                                text: include_str!("../../templates/deletion.txt").into(),
-                                url: format!("{}/delete/", config.hosts.app),
-                                html: Some(include_str!("../../templates/deletion.html").into()),
-                            },
-                            welcome: None,
-                        }
-                    } else {
-                        Templates {
-                            verify: Template {
-                                title: "Verify your account.".into(),
-                                text: include_str!("../../templates/verify.whitelabel.txt").into(),
-                                url: format!("{}/login/verify/", config.hosts.app),
-                                html: None,
-                            },
-                            reset: Template {
-                                title: "Reset your password.".into(),
-                                text: include_str!("../../templates/reset.whitelabel.txt").into(),
-                                url: format!("{}/login/reset/", config.hosts.app),
-                                html: None,
-                            },
-                            reset_existing: Template {
-                                title: "Reset your password.".into(),
-                                text: include_str!("../../templates/reset.whitelabel.txt").into(),
-                                url: format!("{}/login/reset/", config.hosts.app),
-                                html: None,
-                            },
-                            deletion: Template {
-                                title: "Confirm account deletion.".into(),
-                                text: include_str!("../../templates/deletion.whitelabel.txt")
-                                    .into(),
-                                url: format!("{}/delete/", config.hosts.app),
-                                html: None,
-                            },
-                            welcome: None,
-                        }
-                    },
-                }
-            } else {
-                EmailVerificationConfig::Disabled
-            },
-            ..Default::default()
-        };
-
-        auth_config.invite_only = config.api.registration.invite_only;
-
-        if !config.api.security.captcha.hcaptcha_key.is_empty() {
-            auth_config.captcha = Captcha::HCaptcha {
-                secret: config.api.security.captcha.hcaptcha_key,
-            };
-        }
-
-        if !config.api.security.authifier_shield_key.is_empty() {
-            auth_config.shield = Shield::Enabled {
-                api_key: config.api.security.authifier_shield_key,
-                strict: false,
-            };
-        }
-
-        if config.api.security.trust_cloudflare {
-            auth_config.resolve_ip = ResolveIp::Cloudflare;
-        }
-
-        Authifier {
-            database: match self {
-                Database::Reference(_) => Default::default(),
-                #[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,
-        }
-    }
-}

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

@@ -11,6 +11,7 @@ use serde::Serialize;
 
 database_derived!(
     /// MongoDB implementation
+    #[derive(Debug)]
     pub struct MongoDb(pub ::mongodb::Client, pub String);
 );
 

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

@@ -3,15 +3,16 @@ use std::{collections::HashMap, sync::Arc};
 use futures::lock::Mutex;
 
 use crate::{
-    Bot, Channel, ChannelCompositeKey, ChannelUnread, Emoji, File, FileHash, Invite, Member,
-    MemberCompositeKey, Message, PolicyChange, RatelimitEvent, Report, Server, ServerBan, Snapshot,
-    User, UserSettings, Webhook,
+    Account, AccountInvite, AuditLogEntry, Bot, Channel, ChannelCompositeKey, ChannelUnread, Emoji,
+    File, FileHash, Invite, MFATicket, Member, MemberCompositeKey, Message, PolicyChange,
+    RatelimitEvent, Report, Server, ServerBan, Session, Snapshot, User, UserSettings, Webhook,
 };
 
 database_derived!(
     /// Reference implementation
-    #[derive(Default)]
+    #[derive(Default, Debug)]
     pub struct ReferenceDb {
+        pub audit_logs: Arc<Mutex<HashMap<String, AuditLogEntry>>>,
         pub bots: Arc<Mutex<HashMap<String, Bot>>>,
         pub channels: Arc<Mutex<HashMap<String, Channel>>>,
         pub channel_invites: Arc<Mutex<HashMap<String, Invite>>>,
@@ -30,5 +31,9 @@ database_derived!(
         pub servers: Arc<Mutex<HashMap<String, Server>>>,
         pub safety_reports: Arc<Mutex<HashMap<String, Report>>>,
         pub safety_snapshots: Arc<Mutex<HashMap<String, Snapshot>>>,
+        pub accounts: Arc<Mutex<HashMap<String, Account>>>,
+        pub account_invites: Arc<Mutex<HashMap<String, AccountInvite>>>,
+        pub sessions: Arc<Mutex<HashMap<String, Session>>>,
+        pub tickets: Arc<Mutex<HashMap<String, MFATicket>>>,
     }
 );

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

@@ -1,15 +1,16 @@
-use authifier::AuthifierEvent;
 use revolt_result::Error;
 use serde::{Deserialize, Serialize};
 
 use revolt_models::v0::{
-    AppendMessage, Channel, ChannelUnread, Emoji, FieldsChannel, FieldsMember, FieldsMessage,
-    FieldsRole, FieldsServer, FieldsUser, FieldsWebhook, Member, MemberCompositeKey, Message,
-    PartialChannel, PartialMember, PartialMessage, PartialRole, PartialServer, PartialUser,
-    PartialWebhook, PolicyChange, RemovalIntention, Report, Server, User, UserSettings, Webhook,
+    AppendMessage, Channel, ChannelSlowmode, ChannelUnread, ChannelVoiceState, Emoji,
+    FieldsChannel, FieldsMember, FieldsMessage, FieldsRole, FieldsServer, FieldsUser,
+    FieldsWebhook, Member, MemberCompositeKey, Message, PartialChannel, PartialEmoji,
+    PartialMember, PartialMessage, PartialRole, PartialServer, PartialUser, PartialUserVoiceState,
+    PartialWebhook, PolicyChange, RemovalIntention, Report, Server, User, UserSettings,
+    UserVoiceState, Webhook,
 };
 
-use crate::Database;
+use crate::{Account, Database, Session};
 
 /// Ping Packet
 #[derive(Serialize, Deserialize, Debug, Clone)]
@@ -20,16 +21,33 @@ pub enum Ping {
 }
 
 /// Fields provided in Ready payload
-#[derive(PartialEq)]
-pub enum ReadyPayloadFields {
-    Users,
-    Servers,
-    Channels,
-    Members,
-    Emoji,
+#[derive(PartialEq, Debug, Clone, Deserialize)]
+pub struct ReadyPayloadFields {
+    pub users: bool,
+    pub servers: bool,
+    pub channels: bool,
+    pub members: bool,
+    pub emojis: bool,
+    pub voice_states: bool,
+    pub user_settings: Vec<String>,
+    pub channel_unreads: bool,
+    pub policy_changes: bool,
+}
 
-    UserSettings(Vec<String>),
-    ChannelUnreads,
+impl Default for ReadyPayloadFields {
+    fn default() -> Self {
+        Self {
+            users: true,
+            servers: true,
+            channels: true,
+            members: true,
+            emojis: true,
+            voice_states: true,
+            user_settings: Vec::new(),
+            channel_unreads: false,
+            policy_changes: true,
+        }
+    }
 }
 
 /// Protocol Events
@@ -37,9 +55,13 @@ pub enum ReadyPayloadFields {
 #[serde(tag = "type")]
 pub enum EventV1 {
     /// Multiple events
-    Bulk { v: Vec<EventV1> },
+    Bulk {
+        v: Vec<EventV1>,
+    },
     /// Error event
-    Error { data: Error },
+    Error {
+        data: Error,
+    },
 
     /// Successfully authenticated
     Authenticated,
@@ -57,17 +79,22 @@ pub enum EventV1 {
         members: Option<Vec<Member>>,
         #[serde(skip_serializing_if = "Option::is_none")]
         emojis: Option<Vec<Emoji>>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        voice_states: Option<Vec<ChannelVoiceState>>,
 
         #[serde(skip_serializing_if = "Option::is_none")]
         user_settings: Option<UserSettings>,
         #[serde(skip_serializing_if = "Option::is_none")]
         channel_unreads: Option<Vec<ChannelUnread>>,
 
-        policy_changes: Vec<PolicyChange>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        policy_changes: Option<Vec<PolicyChange>>,
     },
 
     /// Ping response
-    Pong { data: Ping },
+    Pong {
+        data: Ping,
+    },
     /// New message
     Message(Message),
 
@@ -88,7 +115,10 @@ pub enum EventV1 {
     },
 
     /// Delete message
-    MessageDelete { id: String, channel: String },
+    MessageDelete {
+        id: String,
+        channel: String,
+    },
 
     /// New reaction to a message
     MessageReact {
@@ -114,7 +144,10 @@ pub enum EventV1 {
     },
 
     /// Bulk delete messages
-    BulkMessageDelete { channel: String, ids: Vec<String> },
+    BulkMessageDelete {
+        channel: String,
+        ids: Vec<String>,
+    },
 
     /// New server
     ServerCreate {
@@ -122,6 +155,7 @@ pub enum EventV1 {
         server: Server,
         channels: Vec<Channel>,
         emojis: Vec<Emoji>,
+        voice_states: Vec<ChannelVoiceState>,
     },
 
     /// Update existing server
@@ -133,7 +167,9 @@ pub enum EventV1 {
     },
 
     /// Delete server
-    ServerDelete { id: String },
+    ServerDelete {
+        id: String,
+    },
 
     /// Update existing server member
     ServerMemberUpdate {
@@ -144,7 +180,13 @@ pub enum EventV1 {
     },
 
     /// User joins server
-    ServerMemberJoin { id: String, user: String },
+    ServerMemberJoin {
+        id: String,
+        // Deprecated: use member.id.user
+        #[deprecated = "Use member.id.user instead"]
+        user: String,
+        member: Member,
+    },
 
     /// User left server
     ServerMemberLeave {
@@ -163,10 +205,16 @@ pub enum EventV1 {
     },
 
     /// Server role deleted
-    ServerRoleDelete { id: String, role_id: String },
+    ServerRoleDelete {
+        id: String,
+        role_id: String,
+    },
 
     /// Server roles ranks updated
-    ServerRoleRanksUpdate { id: String, ranks: Vec<String> },
+    ServerRoleRanksUpdate {
+        id: String,
+        ranks: Vec<String>,
+    },
 
     /// Update existing user
     UserUpdate {
@@ -178,9 +226,15 @@ pub enum EventV1 {
     },
 
     /// Relationship with another user changed
-    UserRelationship { id: String, user: User },
+    UserRelationship {
+        id: String,
+        user: User,
+    },
     /// Settings updated remotely
-    UserSettingsUpdate { id: String, update: UserSettings },
+    UserSettingsUpdate {
+        id: String,
+        update: UserSettings,
+    },
 
     /// User has been platform banned or deleted their account
     ///
@@ -191,12 +245,23 @@ pub enum EventV1 {
     /// - Server Memberships
     ///
     /// User flags are specified to explain why a wipe is occurring though not all reasons will necessarily ever appear.
-    UserPlatformWipe { user_id: String, flags: i32 },
+    UserPlatformWipe {
+        user_id: String,
+        flags: i32,
+    },
     /// New emoji
     EmojiCreate(Emoji),
 
+    /// Update existing emoji
+    EmojiUpdate {
+        id: String,
+        data: PartialEmoji,
+    },
+
     /// Delete emoji
-    EmojiDelete { id: String },
+    EmojiDelete {
+        id: String,
+    },
 
     /// New report
     ReportCreate(Report),
@@ -212,19 +277,33 @@ pub enum EventV1 {
     },
 
     /// Delete channel
-    ChannelDelete { id: String },
+    ChannelDelete {
+        id: String,
+    },
 
     /// User joins a group
-    ChannelGroupJoin { id: String, user: String },
+    ChannelGroupJoin {
+        id: String,
+        user: String,
+    },
 
     /// User leaves a group
-    ChannelGroupLeave { id: String, user: String },
+    ChannelGroupLeave {
+        id: String,
+        user: String,
+    },
 
     /// User started typing in a channel
-    ChannelStartTyping { id: String, user: String },
+    ChannelStartTyping {
+        id: String,
+        user: String,
+    },
 
     /// User stopped typing in a channel
-    ChannelStopTyping { id: String, user: String },
+    ChannelStopTyping {
+        id: String,
+        user: String,
+    },
 
     /// User acknowledged message in channel
     ChannelAck {
@@ -244,10 +323,56 @@ pub enum EventV1 {
     },
 
     /// Delete webhook
-    WebhookDelete { id: String },
+    WebhookDelete {
+        id: String,
+    },
 
     /// Auth events
-    Auth(AuthifierEvent),
+    CreateAccount {
+        account: Account,
+    },
+    CreateSession {
+        session: Session,
+    },
+    DeleteSession {
+        user_id: String,
+        session_id: String,
+    },
+    DeleteAllSessions {
+        user_id: String,
+        exclude_session_id: Option<String>,
+    },
+
+    /// Voice events
+    VoiceChannelJoin {
+        id: String,
+        state: UserVoiceState,
+    },
+    VoiceChannelLeave {
+        id: String,
+        user: String,
+    },
+    VoiceChannelMove {
+        user: String,
+        from: String,
+        to: String,
+        state: UserVoiceState,
+    },
+    UserVoiceStateUpdate {
+        id: String,
+        channel_id: String,
+        data: PartialUserVoiceState,
+    },
+    UserMoveVoiceChannel {
+        node: String,
+        from: String,
+        to: String,
+        token: String,
+    },
+    /// User's active slowmodes
+    UserSlowmodes {
+        slowmodes: Vec<ChannelSlowmode>,
+    },
 }
 
 impl EventV1 {

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

@@ -37,6 +37,20 @@ pub struct GenericPayload {
     pub user: User,
 }
 
+#[derive(Serialize, Deserialize, Clone)]
+pub struct DmCallPayload {
+    pub initiator_id: String,
+    pub channel_id: String,
+    pub started_at: Option<String>,
+    pub ended: bool,
+}
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct InternalDmCallPayload {
+    pub payload: DmCallPayload,
+    pub recipients: Option<Vec<String>>,
+}
+
 #[derive(Serialize, Deserialize)]
 #[serde(tag = "type", content = "data")]
 #[allow(clippy::large_enum_variant)]
@@ -46,6 +60,7 @@ pub enum PayloadKind {
     FRReceived(FRReceivedPayload),
     BadgeUpdate(usize),
     Generic(GenericPayload),
+    DmCallStartEnd(DmCallPayload),
 }
 
 #[derive(Serialize, Deserialize)]
@@ -63,3 +78,11 @@ pub struct AckPayload {
     pub channel_id: String,
     pub message_id: String,
 }
+
+/// This is not the same as the AckPayload above, as the state for this event is stored in redis to allow for state updates while the event is queued.
+#[derive(Serialize, Deserialize, Debug)]
+pub struct AckEventPayload {
+    pub user_id: String,
+    pub channel_id: Option<String>,
+    pub server_id: Option<String>,
+}

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

@@ -1,8 +1,8 @@
-use serde::Deserialize;
+use serde::{Serialize, Deserialize};
 
 use super::client::Ping;
 
-#[derive(Deserialize, Debug)]
+#[derive(Serialize, Deserialize, Debug)]
 #[serde(tag = "type")]
 pub enum ClientMessage {
     Authenticate { token: String },

crates/core/database/src/lib.rs

@@ -25,8 +25,8 @@ pub use mongodb;
 #[macro_use]
 extern crate bson;
 
-#[cfg(not(feature = "async-std-runtime"))]
-compile_error!("async-std-runtime feature must be enabled.");
+#[cfg(not(feature = "tokio-runtime"))]
+compile_error!("tokio-runtime feature must be enabled.");
 
 #[macro_export]
 #[cfg(debug_assertions)]
@@ -77,6 +77,78 @@ macro_rules! auto_derived_partial {
     };
 }
 
+/// Internal macro for `generate_diff!`, you should not need to use this yourself.
+macro_rules! generate_field_diff {
+    (optional, $remove:ident, $fieldsmember:path, $self:ident, $before:ident, $partial:ident, $field:ident) => {
+        if $partial.$field.is_some() || $remove.contains(&$fieldsmember) {
+            $before.$field = $self.$field.clone();
+        };
+    };
+
+    (optional, default, $remove:ident, $fieldsmember:path, $self:ident, $before:ident, $partial:ident, $field:ident) => {
+        if $partial.$field.is_some() || $remove.contains(&$fieldsmember) {
+            $before.$field = Some($self.$field.clone());
+        };
+    };
+
+    ($self:ident, $before:ident, $partial:ident, $field:ident) => {
+        if $partial.$field.is_some() {
+            $before.$field = Some($self.$field.clone());
+        };
+    };
+}
+
+/// Generates a partial model containing the data which has changed in an update
+///
+/// ## Usage:
+/// `before` is the "output" containing what the model had before being updated,
+/// this will corraspond to `partial` which is what the data is being changed too.
+///
+/// ```rs
+/// let mut before = PartialModel::default();
+///
+/// generate_diff!(
+///     self,  // database model
+///     before,  // mutable empty partial corrasponding to the current model
+///     partial,  // partial containing what is being updated
+///     remove,  // slice of fields being removed
+///     (
+///         name,  // regular non-nullable non-removable field
+///         (FieldsEnum::Nickname) nickname,  // optional removable field
+///         ((default) FieldsEnum::Roles) roles,  // optional removable field with custom default
+///     )
+/// );
+/// ```
+///
+/// See `Member::generate_diff` `Server::generate_diff` `Role::generate_diff` for full examples
+macro_rules! generate_diff {
+    (
+        $self:ident,
+        $before:ident,
+        $partial:ident,
+        $remove:ident,
+        (
+            $(
+                $(
+                    $(@$optional:tt)? (
+                        $($(@$default:tt)? (default))?
+                        $fieldsmember:path
+                    )
+                )?
+                $field: ident
+            ),*
+            $(,)?
+        )
+    ) => {
+        $(
+            generate_field_diff!(
+                $( $($optional)? optional, $($($default)? default,)? $remove, $fieldsmember,)?
+                $self, $before, $partial, $field
+            );
+        )*
+    }
+}
+
 mod drivers;
 pub use drivers::*;
 
@@ -112,6 +184,9 @@ pub mod tasks;
 mod amqp;
 pub use amqp::amqp::AMQP;
 
+#[cfg(feature = "voice")]
+pub mod voice;
+
 /// Utility function to check if a boolean value is false
 pub fn if_false(t: &bool) -> bool {
     !t

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

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

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

@@ -0,0 +1,25 @@
+use crate::{if_false, Database};
+use revolt_result::Result;
+
+auto_derived_partial!(
+    /// Account invite ticket
+    pub struct AccountInvite {
+        /// Invite code
+        #[serde(rename = "_id")]
+        pub id: String,
+        /// Whether this invite ticket has been used
+        #[serde(skip_serializing_if = "if_false", default)]
+        pub used: bool,
+        /// User ID that this invite was claimed by
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub claimed_by: Option<String>,
+    },
+    "PartialAccountInvite"
+);
+
+impl AccountInvite {
+    /// Save model
+    pub async fn save(&self, db: &Database) -> Result<()> {
+        db.save_account_invite(self).await
+    }
+}

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

@@ -0,0 +1,16 @@
+use revolt_result::Result;
+
+use crate::AccountInvite;
+
+#[cfg(feature = "mongodb")]
+mod mongodb;
+mod reference;
+
+#[async_trait]
+pub trait AbstractAccountInvites: Sync + Send {
+    /// Find invite by id
+    async fn fetch_account_invite(&self, id: &str) -> Result<AccountInvite>;
+
+    /// Save invite
+    async fn save_account_invite(&self, invite: &AccountInvite) -> Result<()>;
+}

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

@@ -0,0 +1,31 @@
+use crate::{AbstractAccountInvites, AccountInvite, MongoDb};
+use bson::to_document;
+use mongodb::options::UpdateOptions;
+use revolt_result::Result;
+
+const COL: &str = "account_invites";
+
+#[async_trait]
+impl AbstractAccountInvites for MongoDb {
+    /// Find invite by id
+    async fn fetch_account_invite(&self, id: &str) -> Result<AccountInvite> {
+        query!(self, find_one_by_id, COL, id)?.ok_or_else(|| create_error!(InvalidInvite))
+    }
+
+    /// Save invite
+    async fn save_account_invite(&self, invite: &AccountInvite) -> Result<()> {
+        self.col::<AccountInvite>(COL)
+            .update_one(
+                doc! {
+                    "_id": &invite.id
+                },
+                doc! {
+                    "$set": to_document(invite).map_err(|_| create_database_error!("to_document", COL))?,
+                },
+            )
+            .with_options(UpdateOptions::builder().upsert(true).build())
+            .await
+            .map_err(|_| create_database_error!("upsert_one", COL))
+            .map(|_| ())
+    }
+}

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

@@ -0,0 +1,21 @@
+use crate::{AbstractAccountInvites, AccountInvite, ReferenceDb};
+use revolt_result::Result;
+
+#[async_trait]
+impl AbstractAccountInvites for ReferenceDb {
+    /// Find invite by id
+    async fn fetch_account_invite(&self, id: &str) -> Result<AccountInvite> {
+        let invites = self.account_invites.lock().await;
+        invites
+            .get(id)
+            .cloned()
+            .ok_or_else(|| create_error!(InvalidInvite))
+    }
+
+    /// Save invite
+    async fn save_account_invite(&self, invite: &AccountInvite) -> Result<()> {
+        let mut invites = self.account_invites.lock().await;
+        invites.insert(invite.id.to_string(), invite.clone());
+        Ok(())
+    }
+}

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

@@ -0,0 +1,22 @@
+use axum::{extract::{FromRef, FromRequestParts}, http::request::Parts};
+
+use revolt_result::{Error, Result};
+
+use crate::{Account, Database, Session};
+
+#[async_trait]
+impl<S> FromRequestParts<S> for Account
+where
+    Database: FromRef<S>,
+    S: Send + Sync
+{
+    type Rejection = Error;
+
+    async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<Self> {
+        let db = Database::from_ref(state);
+
+        let session = Session::from_request_parts(parts, state).await?;
+
+        db.fetch_account(&session.user_id).await
+    }
+}

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

@@ -0,0 +1,11 @@
+#[cfg(feature = "axum-impl")]
+mod axum;
+mod model;
+mod ops;
+#[cfg(feature = "rocket-impl")]
+mod rocket;
+#[cfg(feature = "rocket-impl")]
+mod schema;
+
+pub use model::*;
+pub use ops::*;

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

@@ -0,0 +1,656 @@
+use iso8601_timestamp::{Duration, Timestamp};
+
+use nanoid::nanoid;
+use revolt_config::config;
+use revolt_result::Result;
+use serde_json::json;
+
+use crate::{
+    events::client::EventV1,
+    util::{
+        email::{email_templates, normalise_email, send_email},
+        password::hash_password,
+    },
+    Database, MFATicket, Session,
+};
+use revolt_models::v0;
+
+auto_derived_partial!(
+    /// Account model
+    pub struct Account {
+        /// Unique Id
+        #[serde(rename = "_id")]
+        pub id: String,
+
+        /// User's email
+        pub email: String,
+
+        /// Normalised email
+        ///
+        /// (see https://github.com/insertish/authifier/#how-does-authifier-work)
+        pub email_normalised: String,
+
+        /// Argon2 hashed password
+        pub password: String,
+
+        /// Whether the account is disabled
+        #[serde(default)]
+        pub disabled: bool,
+
+        /// Email verification status
+        pub verification: EmailVerification,
+
+        /// Password reset information
+        pub password_reset: Option<PasswordReset>,
+
+        /// Account deletion information
+        pub deletion: Option<DeletionInfo>,
+
+        /// Account lockout
+        pub lockout: Option<Lockout>,
+
+        /// Multi-factor authentication information
+        pub mfa: MultiFactorAuthentication,
+    },
+    "PartialAccount"
+);
+
+auto_derived!(
+    /// Email verification status
+    #[serde(tag = "status")]
+    pub enum EmailVerification {
+        /// Account is verified
+        Verified,
+        /// Pending email verification
+        Pending { token: String, expiry: Timestamp },
+        /// Moving to a new email
+        Moving {
+            new_email: String,
+            token: String,
+            expiry: Timestamp,
+        },
+    }
+
+    /// Password reset information
+    pub struct PasswordReset {
+        /// Token required to change password
+        pub token: String,
+        /// Time at which this token expires
+        pub expiry: Timestamp,
+    }
+
+    /// Account deletion information
+    #[serde(tag = "status")]
+    pub enum DeletionInfo {
+        /// The user must confirm deletion by email
+        WaitingForVerification { token: String, expiry: Timestamp },
+        /// The account is scheduled for deletion
+        Scheduled { after: Timestamp },
+        /// This account was deleted
+        Deleted,
+    }
+
+    /// Lockout information
+    pub struct Lockout {
+        /// Attempt counter
+        pub attempts: i32,
+        /// Time at which this lockout expires
+        pub expiry: Option<Timestamp>,
+    }
+
+    /// MFA configuration
+    #[derive(Default)]
+    pub struct MultiFactorAuthentication {
+        /// Allow password-less email OTP login
+        /// (1-Factor)
+        // #[serde(skip_serializing_if = "is_false", default)]
+        // pub enable_email_otp: bool,
+
+        /// Allow trusted handover
+        /// (1-Factor)
+        // #[serde(skip_serializing_if = "is_false", default)]
+        // pub enable_trusted_handover: bool,
+
+        /// Allow email MFA
+        /// (2-Factor)
+        // #[serde(skip_serializing_if = "is_false", default)]
+        // pub enable_email_mfa: bool,
+
+        /// TOTP MFA token, enabled if present
+        /// (2-Factor)
+        #[serde(skip_serializing_if = "Totp::is_empty", default)]
+        pub totp_token: Totp,
+
+        /// Security Key MFA token, enabled if present
+        /// (2-Factor)
+        // #[serde(skip_serializing_if = "Option::is_none")]
+        // pub security_key_token: Option<String>,
+
+        /// Recovery codes
+        #[serde(skip_serializing_if = "Vec::is_empty", default)]
+        pub recovery_codes: Vec<String>,
+    }
+
+    /// MFA method
+    #[derive(Hash)]
+    pub enum MFAMethod {
+        Password,
+        Recovery,
+        Totp,
+    }
+
+    #[derive(Default)]
+    #[serde(tag = "status")]
+    pub enum Totp {
+        /// Disabled
+        #[default]
+        Disabled,
+        /// Waiting for user activation
+        Pending { secret: String },
+        /// Required on account
+        Enabled { secret: String },
+    }
+);
+
+impl MultiFactorAuthentication {
+    // Check whether MFA is in-use
+    pub fn is_active(&self) -> bool {
+        matches!(self.totp_token, Totp::Enabled { .. })
+    }
+
+    // Check whether there are still usable recovery codes
+    pub fn has_recovery(&self) -> bool {
+        !self.recovery_codes.is_empty()
+    }
+
+    // Get available MFA methods
+    pub fn get_methods(&self) -> Vec<MFAMethod> {
+        if let Totp::Enabled { .. } = self.totp_token {
+            let mut methods = vec![MFAMethod::Totp];
+
+            if self.has_recovery() {
+                methods.push(MFAMethod::Recovery);
+            }
+
+            methods
+        } else {
+            vec![MFAMethod::Password]
+        }
+    }
+
+    // Generate new recovery codes
+    pub fn generate_recovery_codes(&mut self) {
+        static ALPHABET: [char; 32] = [
+            '1', '2', '3', '4', '5', '6', '7', '8', '9', '0', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
+            'h', 'j', 'k', 'm', 'n', 'p', 'q', 'r', 's', 't', 'v', 'w', 'x', 'y', 'z',
+        ];
+
+        let mut codes = vec![];
+        for _ in 1..=10 {
+            codes.push(format!(
+                "{}-{}",
+                nanoid!(5, &ALPHABET),
+                nanoid!(5, &ALPHABET)
+            ));
+        }
+
+        self.recovery_codes = codes;
+    }
+
+    // Generate new TOTP secret
+    pub fn generate_new_totp_secret(&mut self) -> Result<String> {
+        if let Totp::Enabled { .. } = self.totp_token {
+            return Err(create_error!(OperationFailed));
+        }
+
+        let secret: [u8; 10] = rand::random();
+        let secret = base32::encode(base32::Alphabet::RFC4648 { padding: false }, &secret);
+
+        self.totp_token = Totp::Pending {
+            secret: secret.clone(),
+        };
+
+        Ok(secret)
+    }
+
+    /// Enable TOTP using a given MFA response
+    pub fn enable_totp(&mut self, response: v0::MFAResponse) -> Result<()> {
+        if let v0::MFAResponse::Totp { totp_code } = response {
+            let code = self.totp_token.generate_code()?;
+
+            if code == totp_code {
+                let mut totp = Totp::Disabled;
+                std::mem::swap(&mut totp, &mut self.totp_token);
+
+                if let Totp::Pending { secret } = totp {
+                    self.totp_token = Totp::Enabled { secret };
+
+                    Ok(())
+                } else {
+                    Err(create_error!(OperationFailed))
+                }
+            } else {
+                Err(create_error!(InvalidToken))
+            }
+        } else {
+            Err(create_error!(InvalidToken))
+        }
+    }
+}
+
+impl Totp {
+    /// Whether TOTP information is empty
+    pub fn is_empty(&self) -> bool {
+        matches!(self, Totp::Disabled)
+    }
+
+    /// Whether TOTP is disabled
+    pub fn is_disabled(&self) -> bool {
+        !matches!(self, Totp::Enabled { .. })
+    }
+
+    // Generate a TOTP code from secret
+    pub fn generate_code(&self) -> Result<String> {
+        if let Totp::Enabled { secret } | Totp::Pending { secret } = &self {
+            let seconds: u64 = std::time::SystemTime::now()
+                .duration_since(std::time::UNIX_EPOCH)
+                .unwrap()
+                .as_secs();
+
+            Ok(totp_lite::totp_custom::<totp_lite::Sha1>(
+                totp_lite::DEFAULT_STEP,
+                6,
+                &base32::decode(base32::Alphabet::RFC4648 { padding: false }, secret)
+                    .expect("valid base32 secret"),
+                seconds,
+            ))
+        } else {
+            Err(create_error!(OperationFailed))
+        }
+    }
+}
+
+impl Account {
+    /// Save model
+    pub async fn save(&self, db: &Database) -> Result<()> {
+        db.save_account(self).await
+    }
+
+    /// Create a new account
+    pub async fn new(
+        db: &Database,
+        email: String,
+        plaintext_password: String,
+        verify_email: bool,
+    ) -> Result<Account> {
+        // Get a normalised representation of the user's email
+        let email_normalised = normalise_email(email.clone());
+
+        // Try to find an existing account
+        if let Some(mut account) = db
+            .fetch_account_by_normalised_email(&email_normalised)
+            .await?
+        {
+            // Resend account verification or send password reset
+            if let EmailVerification::Pending { .. } = &account.verification {
+                account.start_email_verification(db).await?;
+            } else {
+                account.start_password_reset(db, true).await?;
+            }
+
+            Ok(account)
+        } else {
+            // Hash the user's password
+            let password = hash_password(plaintext_password)?;
+
+            // Create a new account
+            let mut account = Account {
+                id: ulid::Ulid::new().to_string(),
+
+                email,
+                email_normalised,
+                password,
+
+                disabled: false,
+                verification: EmailVerification::Verified,
+                password_reset: None,
+                deletion: None,
+                lockout: None,
+
+                mfa: Default::default(),
+            };
+
+            // Send email verification
+            if verify_email {
+                account.start_email_verification(db).await?;
+            } else {
+                account.save(db).await?;
+            }
+
+            // Create and push event
+            EventV1::CreateAccount {
+                account: account.clone(),
+            }
+            .global()
+            .await;
+
+            Ok(account)
+        }
+    }
+
+    /// Create a new session
+    pub async fn create_session(&self, db: &Database, name: String) -> Result<Session> {
+        let config = config().await;
+
+        let session = Session {
+            id: ulid::Ulid::new().to_string(),
+            token: nanoid!(64),
+
+            user_id: self.id.clone(),
+            name,
+
+            last_seen: Timestamp::now_utc(),
+
+            origin: Some(config.environment),
+            subscription: None,
+        };
+
+        // Save to database
+        db.save_session(&session).await?;
+
+        // Create and push event
+        EventV1::CreateSession {
+            session: session.clone(),
+        }
+        .global()
+        .await;
+
+        Ok(session)
+    }
+
+    /// Send account verification email
+    pub async fn start_email_verification(&mut self, db: &Database) -> Result<()> {
+        let config = config().await;
+
+        if !config.api.smtp.host.is_empty() {
+            let templates = email_templates().await;
+
+            let token = nanoid!(32);
+            let url = format!("{}{}", templates.verify.url, token);
+
+            send_email(
+                &config.api.smtp,
+                self.email.clone(),
+                &templates.verify,
+                json!({
+                    "email": self.email.clone(),
+                    "url": url
+                }),
+            )?;
+
+            self.verification = EmailVerification::Pending {
+                token,
+                expiry: Timestamp::now_utc()
+                    .checked_add(Duration::seconds(
+                        config.api.smtp.expiry.expire_verification,
+                    ))
+                    .unwrap(),
+            };
+        } else {
+            self.verification = EmailVerification::Verified;
+        }
+
+        self.save(db).await
+    }
+
+    /// Send account verification to new email
+    pub async fn start_email_move(&mut self, db: &Database, new_email: String) -> Result<()> {
+        // This method should and will never be called on an unverified account,
+        // but just validate this just in case.
+        if let EmailVerification::Pending { .. } = self.verification {
+            return Err(create_error!(UnverifiedAccount));
+        }
+
+        let config = config().await;
+
+        if !config.api.smtp.host.is_empty() {
+            let templates = email_templates().await;
+
+            let token = nanoid!(32);
+            let url = format!("{}{}", templates.verify.url, token);
+
+            send_email(
+                &config.api.smtp,
+                new_email.clone(),
+                &templates.verify,
+                json!({
+                    "email": self.email.clone(),
+                    "url": url
+                }),
+            )?;
+
+            self.verification = EmailVerification::Moving {
+                new_email,
+                token,
+                expiry: Timestamp::now_utc()
+                    .checked_add(Duration::seconds(
+                        config.api.smtp.expiry.expire_verification,
+                    ))
+                    .unwrap(),
+            };
+        } else {
+            self.email_normalised = normalise_email(new_email.clone());
+            self.email = new_email;
+        }
+
+        self.save(db).await
+    }
+
+    /// Send password reset email
+    pub async fn start_password_reset(
+        &mut self,
+        db: &Database,
+        existing_account: bool,
+    ) -> Result<()> {
+        let config = config().await;
+
+        if !config.api.smtp.host.is_empty() {
+            let templates = email_templates().await;
+
+            let template = if existing_account {
+                &templates.reset_existing
+            } else {
+                &templates.reset
+            };
+
+            let token = nanoid!(32);
+            let url = format!("{}{}", template.url, token);
+
+            send_email(
+                &config.api.smtp,
+                self.email.clone(),
+                template,
+                json!({
+                    "email": self.email.clone(),
+                    "url": url
+                }),
+            )?;
+
+            self.password_reset = Some(PasswordReset {
+                token,
+                expiry: Timestamp::now_utc()
+                    .checked_add(Duration::seconds(
+                        config.api.smtp.expiry.expire_password_reset,
+                    ))
+                    .unwrap(),
+            });
+        } else {
+            return Err(create_error!(OperationFailed));
+        }
+
+        self.save(db).await
+    }
+
+    /// Begin account deletion process by sending confirmation email
+    ///
+    /// If email verification is not on, the account will be marked for deletion instantly
+    pub async fn start_account_deletion(&mut self, db: &Database) -> Result<()> {
+        let config = config().await;
+
+        if !config.api.smtp.host.is_empty() {
+            let templates = email_templates().await;
+
+            let token = nanoid!(32);
+            let url = format!("{}{}", templates.deletion.url, token);
+
+            send_email(
+                &config.api.smtp,
+                self.email.clone(),
+                &templates.deletion,
+                json!({
+                    "email": self.email.clone(),
+                    "url": url
+                }),
+            )?;
+
+            self.deletion = Some(DeletionInfo::WaitingForVerification {
+                token,
+                expiry: Timestamp::now_utc()
+                    .checked_add(Duration::seconds(
+                        config.api.smtp.expiry.expire_password_reset,
+                    ))
+                    .unwrap(),
+            });
+
+            self.save(db).await
+        } else {
+            self.schedule_deletion(db).await
+        }
+    }
+
+    /// Verify a user's password is correct
+    pub fn verify_password(&self, plaintext_password: &str) -> Result<()> {
+        argon2::verify_encoded(&self.password, plaintext_password.as_bytes())
+            .map(|v| {
+                if v {
+                    Ok(())
+                } else {
+                    Err(create_error!(InvalidCredentials))
+                }
+            })
+            // To prevent user enumeration, we should ignore
+            // the error and pretend the password is wrong.
+            .map_err(|_| create_error!(InvalidCredentials))?
+    }
+
+    /// Validate an MFA response
+    pub async fn consume_mfa_response(
+        &mut self,
+        db: &Database,
+        response: v0::MFAResponse,
+        ticket: Option<MFATicket>,
+    ) -> Result<()> {
+        let allowed_methods = self.mfa.get_methods();
+
+        match response {
+            v0::MFAResponse::Password { password } => {
+                if allowed_methods.contains(&MFAMethod::Password) {
+                    self.verify_password(&password)
+                } else {
+                    Err(create_error!(DisallowedMFAMethod))
+                }
+            }
+            v0::MFAResponse::Totp { totp_code } => {
+                if allowed_methods.contains(&MFAMethod::Totp) {
+                    if let Totp::Enabled { .. } = &self.mfa.totp_token {
+                        // Use TOTP code at generation if applicable
+                        if let Some(ticket) = ticket {
+                            if let Some(code) = ticket.last_totp_code {
+                                if code == totp_code {
+                                    return Ok(());
+                                }
+                            }
+                        }
+
+                        // Otherwise read current TOTP token
+                        if self.mfa.totp_token.generate_code()? == totp_code {
+                            Ok(())
+                        } else {
+                            Err(create_error!(InvalidToken))
+                        }
+                    } else {
+                        unreachable!()
+                    }
+                } else {
+                    Err(create_error!(DisallowedMFAMethod))
+                }
+            }
+            v0::MFAResponse::Recovery { recovery_code } => {
+                if allowed_methods.contains(&MFAMethod::Recovery) {
+                    if let Some(index) = self
+                        .mfa
+                        .recovery_codes
+                        .iter()
+                        .position(|x| x == &recovery_code)
+                    {
+                        self.mfa.recovery_codes.remove(index);
+                        self.save(db).await
+                    } else {
+                        Err(create_error!(InvalidToken))
+                    }
+                } else {
+                    Err(create_error!(DisallowedMFAMethod))
+                }
+            }
+        }
+    }
+
+    /// Delete all sessions for an account
+    pub async fn delete_all_sessions(
+        &self,
+        db: &Database,
+        exclude_session_id: Option<String>,
+    ) -> Result<()> {
+        db.delete_all_sessions(&self.id, exclude_session_id.clone())
+            .await?;
+
+        // Create and push event
+        EventV1::DeleteAllSessions {
+            user_id: self.id.clone(),
+            exclude_session_id,
+        }
+        .private(self.id.clone())
+        .await;
+
+        Ok(())
+    }
+
+    /// Disable an account
+    pub async fn disable(&mut self, db: &Database) -> Result<()> {
+        self.disabled = true;
+        self.delete_all_sessions(db, None).await?;
+        self.save(db).await
+    }
+
+    /// Schedule an account for deletion
+    pub async fn schedule_deletion(&mut self, db: &Database) -> Result<()> {
+        self.deletion = Some(DeletionInfo::Scheduled {
+            after: Timestamp::now_utc()
+                .checked_add(Duration::weeks(1))
+                .unwrap(),
+        });
+
+        self.disable(db).await
+    }
+
+    /// Removes all information from the account and marks it as fully deleted
+    pub async fn mark_deleted(&mut self, db: &Database) -> Result<()> {
+        self.email = format!("Deleted User {}", &self.id);
+        self.email_normalised = format!("Deleted User {}", &self.id);
+        self.deletion = Some(DeletionInfo::Deleted);
+
+        self.save(db).await?;
+
+        Ok(())
+    }
+}

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

@@ -0,0 +1,34 @@
+use revolt_result::Result;
+
+use crate::Account;
+
+#[cfg(feature = "mongodb")]
+mod mongodb;
+mod reference;
+
+#[async_trait]
+pub trait AbstractAccounts: Sync + Send {
+    /// Find account by id
+    async fn fetch_account(&self, id: &str) -> Result<Account>;
+
+    /// Find account by normalised email
+    async fn fetch_account_by_normalised_email(
+        &self,
+        normalised_email: &str,
+    ) -> Result<Option<Account>>;
+
+    /// Find account with active pending email verification
+    async fn fetch_account_with_email_verification(&self, token: &str) -> Result<Account>;
+
+    /// Find account with active password reset
+    async fn fetch_account_with_password_reset(&self, token: &str) -> Result<Account>;
+
+    /// Find account with active deletion token
+    async fn fetch_account_with_deletion_token(&self, token: &str) -> Result<Account>;
+
+    /// Find accounts which are due to be deleted
+    async fn fetch_accounts_due_for_deletion(&self) -> Result<Vec<Account>>;
+
+    // Save account
+    async fn save_account(&self, account: &Account) -> Result<()>;
+}

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

@@ -0,0 +1,118 @@
+use crate::{AbstractAccounts, Account, MongoDb};
+use bson::{to_bson, to_document};
+use iso8601_timestamp::Timestamp;
+use mongodb::options::{Collation, CollationStrength, FindOneOptions, UpdateOptions};
+use revolt_result::Result;
+
+const COL: &str = "accounts";
+
+#[async_trait]
+impl AbstractAccounts for MongoDb {
+    /// Find account by id
+    async fn fetch_account(&self, id: &str) -> Result<Account> {
+        query!(self, find_one_by_id, COL, id)?.ok_or_else(|| create_error!(UnknownUser))
+    }
+
+    /// Find account by normalised email
+    async fn fetch_account_by_normalised_email(
+        &self,
+        normalised_email: &str,
+    ) -> Result<Option<Account>> {
+        query!(
+            self,
+            find_one_with_options,
+            COL,
+            doc! {
+                "email_normalised": normalised_email
+            },
+            FindOneOptions::builder()
+                .collation(
+                    Collation::builder()
+                        .locale("en")
+                        .strength(CollationStrength::Secondary)
+                        .build(),
+                )
+                .build()
+        )
+    }
+
+    /// Find account with active pending email verification
+    async fn fetch_account_with_email_verification(&self, token: &str) -> Result<Account> {
+        query!(
+            self,
+            find_one,
+            COL,
+            doc! {
+                "verification.token": token,
+                "verification.expiry": {
+                    "$gte": to_bson(&Timestamp::now_utc()).unwrap()
+                }
+            }
+        )?
+        .ok_or_else(|| create_error!(InvalidToken))
+    }
+
+    /// Find account with active password reset
+    async fn fetch_account_with_password_reset(&self, token: &str) -> Result<Account> {
+        query!(
+            self,
+            find_one,
+            COL,
+            doc! {
+                "password_reset.token": token,
+                "password_reset.expiry": {
+                    "$gte": to_bson(&Timestamp::now_utc()).unwrap()
+                }
+            }
+        )?
+        .ok_or_else(|| create_error!(InvalidToken))
+    }
+
+    /// Find account with active deletion token
+    async fn fetch_account_with_deletion_token(&self, token: &str) -> Result<Account> {
+        query!(
+            self,
+            find_one,
+            COL,
+            doc! {
+                "deletion.token": token,
+                "deletion.expiry": {
+                    "$gte": to_bson(&Timestamp::now_utc()).unwrap()
+                }
+            }
+        )?
+        .ok_or_else(|| create_error!(InvalidToken))
+    }
+
+    /// Find accounts which are due to be deleted
+    async fn fetch_accounts_due_for_deletion(&self) -> Result<Vec<Account>> {
+        query!(
+            self,
+            find,
+            COL,
+            doc! {
+                "deletion.status": "Scheduled",
+                "deletion.after": {
+                    "$lte": to_bson(&Timestamp::now_utc()).unwrap()
+                }
+            }
+        )
+    }
+
+    // Save account
+    async fn save_account(&self, account: &Account) -> Result<()> {
+        self.col::<Account>(COL)
+            .update_one(
+                doc! {
+                    "_id": &account.id
+                },
+                doc! {
+                    "$set": to_document(account).map_err(|_| create_database_error!("to_document", COL))?
+                },
+            )
+            .with_options(UpdateOptions::builder().upsert(true).build())
+            .await
+            .map_err(|_| create_database_error!("find_one", COL))
+            .map(|_| ())
+    }
+}

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

@@ -0,0 +1,99 @@
+use crate::{AbstractAccounts, Account, DeletionInfo, EmailVerification, ReferenceDb};
+use iso8601_timestamp::Timestamp;
+use revolt_result::Result;
+
+#[async_trait]
+impl AbstractAccounts for ReferenceDb {
+    /// Find account by id
+    async fn fetch_account(&self, id: &str) -> Result<Account> {
+        let accounts = self.accounts.lock().await;
+        accounts
+            .get(id)
+            .cloned()
+            .ok_or_else(|| create_error!(UnknownUser))
+    }
+
+    /// Find account by normalised email
+    async fn fetch_account_by_normalised_email(
+        &self,
+        normalised_email: &str,
+    ) -> Result<Option<Account>> {
+        let accounts = self.accounts.lock().await;
+        Ok(accounts
+            .values()
+            .find(|account| account.email_normalised == normalised_email)
+            .cloned())
+    }
+
+    /// Find account with active pending email verification
+    async fn fetch_account_with_email_verification(&self, token_to_match: &str) -> Result<Account> {
+        let accounts = self.accounts.lock().await;
+        accounts
+            .values()
+            .find(|account| match &account.verification {
+                EmailVerification::Pending { token, .. }
+                | EmailVerification::Moving { token, .. } => token == token_to_match,
+                _ => false,
+            })
+            .cloned()
+            .ok_or_else(|| create_error!(InvalidToken))
+    }
+
+    /// Find account with active password reset
+    async fn fetch_account_with_password_reset(&self, token: &str) -> Result<Account> {
+        let accounts = self.accounts.lock().await;
+        accounts
+            .values()
+            .find(|account| {
+                if let Some(reset) = &account.password_reset {
+                    reset.token == token
+                } else {
+                    false
+                }
+            })
+            .cloned()
+            .ok_or_else(|| create_error!(InvalidToken))
+    }
+
+    /// Find account with active deletion token
+    async fn fetch_account_with_deletion_token(&self, token_to_match: &str) -> Result<Account> {
+        let accounts = self.accounts.lock().await;
+        accounts
+            .values()
+            .find(|account| {
+                if let Some(DeletionInfo::WaitingForVerification { token, .. }) = &account.deletion
+                {
+                    token == token_to_match
+                } else {
+                    false
+                }
+            })
+            .cloned()
+            .ok_or_else(|| create_error!(InvalidToken))
+    }
+
+    /// Find accounts which are due to be deleted
+    async fn fetch_accounts_due_for_deletion(&self) -> Result<Vec<Account>> {
+        let now = Timestamp::now_utc();
+        let accounts = self.accounts.lock().await;
+
+        Ok(accounts
+            .values()
+            .filter(|account| {
+                if let Some(DeletionInfo::Scheduled { after }) = &account.deletion {
+                    after <= &now
+                } else {
+                    false
+                }
+            })
+            .cloned()
+            .collect())
+    }
+
+    // Save account
+    async fn save_account(&self, account: &Account) -> Result<()> {
+        let mut accounts = self.accounts.lock().await;
+        accounts.insert(account.id.to_string(), account.clone());
+        Ok(())
+    }
+}

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

@@ -0,0 +1,32 @@
+use crate::{Account, Database, Session};
+use revolt_result::Error;
+use rocket::{
+    http::Status,
+    request::{FromRequest, Outcome},
+    Request,
+};
+
+#[rocket::async_trait]
+impl<'r> FromRequest<'r> for Account {
+    type Error = Error;
+
+    async fn from_request(request: &'r Request<'_>) -> Outcome<Self, Self::Error> {
+        match request.guard::<Session>().await {
+            Outcome::Success(session) => {
+                if let Ok(account) = request
+                    .rocket()
+                    .state::<Database>()
+                    .expect("`Database`")
+                    .fetch_account(&session.user_id)
+                    .await
+                {
+                    Outcome::Success(account)
+                } else {
+                    Outcome::Error((Status::InternalServerError, create_error!(InternalError)))
+                }
+            }
+            Outcome::Forward(_) => unreachable!(),
+            Outcome::Error(err) => Outcome::Error(err),
+        }
+    }
+}

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

@@ -0,0 +1,32 @@
+use revolt_okapi::openapi3::{SecurityScheme, SecuritySchemeData};
+use revolt_rocket_okapi::{
+    gen::OpenApiGenerator,
+    request::{OpenApiFromRequest, RequestHeaderInput},
+};
+
+use crate::Account;
+
+
+impl<'r> OpenApiFromRequest<'r> for Account {
+    fn from_request_input(
+        _gen: &mut OpenApiGenerator,
+        _name: String,
+        _required: bool,
+    ) -> revolt_rocket_okapi::Result<RequestHeaderInput> {
+        let mut requirements = schemars::Map::new();
+        requirements.insert("Session Token".to_owned(), vec![]);
+
+        Ok(RequestHeaderInput::Security(
+            "Session Token".to_owned(),
+            SecurityScheme {
+                data: SecuritySchemeData::ApiKey {
+                    name: "x-session-token".to_owned(),
+                    location: "header".to_owned(),
+                },
+                description: Some("Used to authenticate as a user.".to_owned()),
+                extensions: schemars::Map::new(),
+            },
+            requirements,
+        ))
+    }
+}

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

@@ -11,7 +11,7 @@ auto_derived!(
 
 #[cfg(test)]
 mod tests {
-    #[async_std::test]
+    #[tokio::test]
     async fn migrate() {
         database_test!(|db| async move {
             // Initialise the database

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

@@ -98,6 +98,21 @@ pub async fn create_database(db: &MongoDb) {
         .await
         .expect("Failed to create pubsub collection.");
 
+    db.create_collection("audit_logs")
+        .await
+        .expect("Failed to create audit_logs collection");
+    db.create_collection("sessions")
+        .await
+        .expect("Failed to create sessions collection.");
+
+    db.create_collection("account_invites")
+        .await
+        .expect("Failed to create account_invites collection.");
+
+    db.create_collection("mfa_tickets")
+        .await
+        .expect("Failed to create mfa_tickets collection.");
+
     db.run_command(doc! {
         "createIndexes": "users",
         "indexes": [
@@ -263,5 +278,141 @@ pub async fn create_database(db: &MongoDb) {
     .await
     .expect("Failed to create ratelimit_events index.");
 
+    db.run_command(doc! {
+        "createIndexes": "audit_logs",
+        "indexes": [
+            {
+                "key": {
+                    "expires_at": 1_i32,
+                },
+                "name": "expires_at_ttl",
+                // We set the expire after to 0 because we store when it expires instead of when the document was inserted,
+                // this is because mongo cant read the timestamp from the ulid so we need to do this workaround.
+                // relevant docs: https://www.mongodb.com/docs/manual/tutorial/expire-data/#expire-documents-at-a-specific-clock-time
+                "expireAfterSeconds": 0
+            },
+            {
+                "key": {
+                    "server": 1_i32,
+                    "user": 1_i32,
+                    "action.type": 1_i32,
+                },
+                "name": "audit_log_filters",
+            },
+        ]
+    })
+    .await
+    .expect("Failed to create audit_logs index");
+
+    db.run_command(doc! {
+        "createIndexes": "audit_logs",
+        "indexes": [
+            {
+                "key": {
+                    "expires_at": 1_i32,
+                },
+                "name": "expires_at_ttl",
+                // We set the expire after to 0 because we store when it expires instead of when the document was inserted,
+                // this is because mongo cant read the timestamp from the ulid so we need to do this workaround.
+                // relevant docs: https://www.mongodb.com/docs/manual/tutorial/expire-data/#expire-documents-at-a-specific-clock-time
+                "expireAfterSeconds": 0
+            },
+            {
+                "key": {
+                    "server": 1_i32,
+                    "user": 1_i32,
+                    "action.type": 1_i32,
+                },
+                "name": "audit_log_filters",
+            },
+        ]
+    })
+    .await
+    .expect("Failed to create audit_logs index");
+
+    db.run_command(doc! {
+        "createIndexes": "accounts",
+        "indexes": [
+            {
+                "key": {
+                    "email": 1
+                },
+                "name": "email",
+                "unique": true,
+                "collation": {
+                    "locale": "en",
+                    "strength": 2
+                }
+            },
+            {
+                "key": {
+                    "email_normalised": 1
+                },
+                "name": "email_normalised",
+                "unique": true,
+                "collation": {
+                    "locale": "en",
+                    "strength": 2
+                }
+            },
+            {
+                "key": {
+                    "verification.token": 1
+                },
+                "name": "email_verification"
+            },
+            {
+                "key": {
+                    "password_reset.token": 1
+                },
+                "name": "password_reset"
+            },
+            {
+                "key": {
+                    "deletion.token": 1
+                },
+                "name": "account_deletion"
+            }
+        ]
+    })
+    .await
+    .unwrap();
+
+    db.run_command(doc! {
+        "createIndexes": "sessions",
+        "indexes": [
+            {
+                "key": {
+                    "token": 1
+                },
+                "name": "token",
+                "unique": true
+            },
+            {
+                "key": {
+                    "user_id": 1
+                },
+                "name": "user_id"
+            }
+        ]
+    })
+    .await
+    .unwrap();
+
+    db.run_command(doc! {
+        "createIndexes": "mfa_tickets",
+        "indexes": [
+            {
+                "key": {
+                    "token": 1
+                },
+                "name": "token",
+                "unique": true
+            }
+        ]
+    })
+    .await
+    .unwrap();
+
     info!("Created database.");
 }

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

@@ -9,15 +9,15 @@ use crate::{
         bson::{doc, from_bson, from_document, to_document, Bson, DateTime, Document},
         options::FindOptions,
     },
-    AbstractChannels, AbstractServers, Channel, Invite, MongoDb, User, DISCRIMINATOR_SEARCH_SPACE,
+    AbstractServers, Invite, MongoDb, User, DISCRIMINATOR_SEARCH_SPACE,
 };
 use bson::{oid::ObjectId, to_bson};
 use futures::StreamExt;
 use iso8601_timestamp::Timestamp;
 use rand::seq::SliceRandom;
-use revolt_permissions::DEFAULT_WEBHOOK_PERMISSIONS;
-use revolt_result::{Error, ErrorType};
+use revolt_permissions::{ChannelPermission, DEFAULT_WEBHOOK_PERMISSIONS};
 use serde::{Deserialize, Serialize};
+use ulid::Ulid;
 use unicode_segmentation::UnicodeSegmentation;
 
 #[derive(Serialize, Deserialize)]
@@ -26,7 +26,7 @@ struct MigrationInfo {
     revision: i32,
 }
 
-pub const LATEST_REVISION: i32 = 42; // MUST BE +1 to last migration
+pub const LATEST_REVISION: i32 = 52; // MUST BE +1 to last migration
 
 pub async fn migrate_database(db: &MongoDb) {
     let migrations = db.col::<Document>("migrations");
@@ -452,7 +452,7 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
         warn!("This is a destructive operation and will wipe existing permission data (excl. defaults for SendMessage).");
         warn!("Taking a backup is advised.");
         warn!("Continuing in 10 seconds...");
-        async_std::task::sleep(Duration::from_secs(10)).await;
+        tokio::time::sleep(Duration::from_secs(10)).await;
 
         let servers = db.col::<Document>("servers");
         let mut cursor = servers.find(doc! {}).await.unwrap();
@@ -574,20 +574,145 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
     if revision <= 15 {
         info!("Running migration [revision 15 / 04-06-2022]: Migrate Authifier to latest version.");
 
-        let db = authifier::Database::MongoDb(authifier::database::MongoDb(db.db()));
-        db.run_migration(authifier::Migration::M2022_06_03EnsureUpToSpec)
+        if !db
+            .db()
+            .collection::<Document>("mfa_tickets")
+            .list_index_names()
             .await
-            .unwrap();
+            .unwrap_or_default()
+            .contains(&"token".to_owned())
+        {
+            // Make sure all collections exist
+            let list = db.db().list_collection_names().await.unwrap();
+            let collections = ["accounts", "sessions", "invites", "mfa_tickets"];
+
+            for name in collections {
+                if !list.contains(&name.to_string()) {
+                    db.db().create_collection(name).await.unwrap();
+                }
+            }
+
+            // Setup index for `accounts`
+            let col = db.db().collection::<Document>("accounts");
+            col.drop_indexes().await.unwrap();
+
+            db.db()
+                .run_command(doc! {
+                    "createIndexes": "accounts",
+                    "indexes": [
+                        {
+                            "key": {
+                                "email": 1
+                            },
+                            "name": "email",
+                            "unique": true,
+                            "collation": {
+                                "locale": "en",
+                                "strength": 2
+                            }
+                        },
+                        {
+                            "key": {
+                                "email_normalised": 1
+                            },
+                            "name": "email_normalised",
+                            "unique": true,
+                            "collation": {
+                                "locale": "en",
+                                "strength": 2
+                            }
+                        },
+                        {
+                            "key": {
+                                "verification.token": 1
+                            },
+                            "name": "email_verification"
+                        },
+                        {
+                            "key": {
+                                "password_reset.token": 1
+                            },
+                            "name": "password_reset"
+                        }
+                    ]
+                })
+                .await
+                .unwrap();
+
+            // Setup index for `sessions`
+            let col = db.db().collection::<Document>("sessions");
+            col.drop_indexes().await.unwrap();
+
+            db.db()
+                .run_command(doc! {
+                    "createIndexes": "sessions",
+                    "indexes": [
+                        {
+                            "key": {
+                                "token": 1
+                            },
+                            "name": "token",
+                            "unique": true
+                        },
+                        {
+                            "key": {
+                                "user_id": 1
+                            },
+                            "name": "user_id"
+                        }
+                    ]
+                })
+                .await
+                .unwrap();
+
+            // Setup index for `mfa_tickets`
+            let col = db.db().collection::<Document>("mfa_tickets");
+            col.drop_indexes().await.unwrap();
+
+            db.db()
+                .run_command(doc! {
+                    "createIndexes": "mfa_tickets",
+                    "indexes": [
+                        {
+                            "key": {
+                                "token": 1
+                            },
+                            "name": "token",
+                            "unique": true
+                        }
+                    ]
+                })
+                .await
+                .unwrap();
+        }
     }
 
     if revision <= 16 {
         info!("Running migration [revision 16 / 07-07-2022]: Add `emojis` collection and Authifier migration.");
 
-        let authifier_db = authifier::Database::MongoDb(authifier::database::MongoDb(db.db()));
-        authifier_db
-            .run_migration(authifier::Migration::M2022_06_09AddIndexForDeletion)
+        if !db
+            .db()
+            .collection::<Document>("accounts")
+            .list_index_names()
             .await
-            .unwrap();
+            .expect("list of index names")
+            .contains(&"account_deletion".to_owned())
+        {
+            db.db()
+                .run_command(doc! {
+                    "createIndexes": "accounts",
+                    "indexes": [
+                        {
+                            "key": {
+                                "deletion.token": 1
+                            },
+                            "name": "account_deletion"
+                        }
+                    ]
+                })
+                .await
+                .unwrap();
+        }
 
         db.db()
             .create_collection("emojis")
@@ -914,6 +1039,7 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
     }
 
     if revision <= 26 {
+        // Need to migrate fields on attachments, change `user_id`, `object_id`, etc to `parent`.
         info!("Running migration [revision 26 / 15-05-2024]: fix invites being incorrectly serialized with wrong enum tagging.");
 
         auto_derived!(
@@ -1080,6 +1206,14 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
             channel_id: String,
         }
 
+        #[allow(clippy::enum_variant_names)]
+        #[derive(serde::Serialize, serde::Deserialize)]
+        enum Channel {
+            Group { owner: String },
+            TextChannel { server: String },
+            VoiceChannel { server: String },
+        }
+
         let webhooks = db
             .db()
             .collection::<WebhookShell>("channel_webhooks")
@@ -1091,8 +1225,13 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
             .await;
 
         for webhook in webhooks {
-            match db.fetch_channel(&webhook.channel_id).await {
-                Ok(channel) => {
+            match db
+                .col::<Channel>("channels")
+                .find_one(doc! { "_id": &webhook.channel_id })
+                .await
+                .unwrap()
+            {
+                Some(channel) => {
                     let creator_id = match channel {
                         Channel::Group { owner, .. } => owner,
                         Channel::TextChannel { server, .. }
@@ -1100,7 +1239,6 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
                             let server = db.fetch_server(&server).await.expect("server");
                             server.owner
                         }
-                        _ => unreachable!("not server or group channel!"),
                     };
 
                     db.db()
@@ -1118,17 +1256,13 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
                         .await
                         .expect("update webhook");
                 }
-                Err(Error {
-                    error_type: ErrorType::NotFound,
-                    ..
-                }) => {
+                None => {
                     db.db()
                         .collection::<WebhookShell>("channel_webhooks")
                         .delete_one(doc! { "_id": webhook._id })
                         .await
                         .expect("failed to delete invalid webhook");
                 }
-                Err(err) => panic!("{err:?}"),
             }
         }
     }
@@ -1138,10 +1272,51 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
             "Running migration [revision 32 / 12-05-2025]: (Authifier) Add last_seen to sessions."
         );
 
-        let db = authifier::Database::MongoDb(authifier::database::MongoDb(db.db()));
-        db.run_migration(authifier::Migration::M2025_02_20AddLastSeenToSession)
-            .await
-            .unwrap();
+        loop {
+            #[derive(Deserialize)]
+            struct SessionId {
+                _id: String,
+            }
+
+            let sessions: Vec<SessionId> = db
+                .db()
+                .collection("sessions")
+                .find(doc! {
+                    "$or": [
+                        { "last_seen": { "$exists": false } },
+                        { "last_seen": "1970-01-01T00:00:00.000Z" }
+                    ]
+                })
+                .limit(50_000) // about 400 batches for 2 million
+                .await
+                .expect("Failed to create cursor for sessions!")
+                .map(|doc| doc.expect("id and username"))
+                .collect()
+                .await;
+
+            if sessions.is_empty() {
+                break;
+            }
+
+            for session in sessions {
+                let timestamp = iso8601_timestamp::Timestamp::from(Ulid::from_string(&session._id).unwrap().datetime());
+
+                db.db()
+                    .collection::<Document>("sessions")
+                    .update_one(
+                        doc! {
+                            "_id": &session._id.to_string(),
+                        },
+                        doc! {
+                            "$set": {
+                                "last_seen": timestamp.format().to_string()
+                            }
+                        },
+                    )
+                    .await
+                    .expect("Failed to update a session.");
+            }
+        }
     }
 
     if revision <= 40 {
@@ -1169,9 +1344,9 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
             .expect("failed to update users");
     }
 
-    if revision <= 41 {
+    if revision <= 43 {
         info!(
-            "Running migration [revision 41 / 05-06-2025]: convert role ranks to uniform numbers."
+            "Running migration [revision 43 / 05-06-2025]: convert role ranks to uniform numbers."
         );
 
         #[derive(Serialize, Deserialize, Clone)]
@@ -1226,6 +1401,128 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
         }
     }
 
+    if revision <= 46 {
+        info!("Running migration [revision 46 / 29-04-2025]: Convert all `VoiceChannel`'s into `TextChannel`");
+
+        db.col::<Document>("channels")
+            .update_many(
+                doc! { "channel_type": "VoiceChannel" },
+                doc! {
+                    "$set": {
+                        "channel_type": "TextChannel",
+                        "voice": {}
+                    }
+                },
+            )
+            .await
+            .expect("Failed to update voice channels");
+    };
+
+    if revision <= 48 {
+        info!("Running migration [revision 48 / 22-10-2025]: Add Video + Listen to default permissions");
+
+        db.col::<Document>("servers")
+            .update_many(
+                doc! { },
+                doc! {
+                    "$bit": {
+                        "default_permissions": {
+                            "or": (ChannelPermission::Video + ChannelPermission::Speak + ChannelPermission::Listen) as i64
+                        },
+                    }
+                }
+            )
+            .await
+            .expect("Failed to update default_permissions");
+    };
+
+    if revision <= 49 {
+        info!("Running migration [revision 49 / 12-12-2025]: Add _id key to roles");
+
+        #[derive(Serialize, Deserialize, Clone)]
+        struct Server {
+            #[serde(rename = "_id")]
+            pub id: String,
+            #[serde(default = "HashMap::<String, Document>::new")]
+            pub roles: HashMap<String, Document>,
+        }
+
+        let mut servers = db
+            .db()
+            .collection::<Server>("servers")
+            .find(doc! {
+                "roles": {
+                    "$exists": true,
+                    "$ne": {}
+                }
+            })
+            .await
+            .unwrap()
+            .map(|res| res.expect("Failed to decode Server { id, roles }"));
+
+        while let Some(server) = servers.next().await {
+            let mut doc = doc! {};
+
+            for id in server.roles.keys() {
+                doc.insert(format!("roles.{id}._id"), id);
+            }
+
+            db.db()
+                .collection::<Server>("servers")
+                .update_one(doc! { "_id": &server.id }, doc! { "$set": doc })
+                .await
+                .unwrap();
+        }
+    };
+
+    if revision <= 50 {
+        info!("Running migration [revision 50 / 13-04-2026]: Rename invites collection to account_invites");
+
+        db.db()
+            .client()
+            .database("admin")
+            .run_command(doc! {
+                "renameCollection": "revolt.invites",
+                "to": "revolt.account_invites",
+                "dropTarget": true
+            })
+            .await
+            .unwrap();
+    }
+
+    if revision >= 51 {
+        info!("Running migration [revision 51 / 28-11-2025]: Add audit logs collection");
+
+        db.db()
+            .create_collection("audit_logs")
+            .await
+            .expect("Failed to create audit_logs collection");
+
+        db.db()
+            .run_command(doc! {
+                "createIndexes": "audit_logs",
+                "indexes": [
+                    {
+                        "key": {
+                            "expires_at": 1_i32,
+                        },
+                        "name": "expires_at_ttl",
+                        "expireAfterSeconds": 0
+                    },
+                    {
+                        "key": {
+                            "server": 1_i32,
+                            "user": 1_i32,
+                            "action.type": 1_i32,
+                        },
+                        "name": "audit_log_filters",
+                    },
+                ]
+            })
+            .await
+            .expect("Failed to create audit_logs index");
+    };
+
     // Reminder to update LATEST_REVISION when adding new migrations.
     LATEST_REVISION.max(revision)
 }

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

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

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

@@ -0,0 +1,275 @@
+use std::{collections::HashSet, time::Duration};
+
+use iso8601_timestamp::Timestamp;
+use revolt_config::config;
+use ulid::Ulid;
+
+use crate::{Database, PartialChannel, PartialMember, PartialRole, PartialServer, User, PartialEmoji};
+use revolt_models::v0;
+use revolt_permissions::OverrideField;
+use revolt_result::Result;
+
+auto_derived!(
+    /// Audit log entry
+    pub struct AuditLogEntry {
+        /// Unique ID
+        #[serde(rename = "_id")]
+        pub id: String,
+
+        /// When the audit log entry gets auto-deleted
+        ///
+        /// This is only stored in the database and not given to users.
+        pub expires_at: Timestamp,
+
+        /// The server the entry happened in
+        pub server: String,
+        /// User provided reason
+        pub reason: Option<String>,
+        /// User who ran the action
+        pub user: String,
+        /// User this action is targetting
+        pub target: Option<String>,
+        /// The action ran
+        pub action: AuditLogEntryAction,
+    }
+
+    /// Indivual audit log action
+    #[serde(tag = "type")]
+    #[allow(clippy::large_enum_variant)]
+    pub enum AuditLogEntryAction {
+        MessageDelete {
+            author: String,
+            channel: String,
+        },
+        MessageBulkDelete {
+            channel: String,
+            count: usize,
+        },
+        MessagePin {
+            message: String,
+            author: String,
+            channel: String,
+        },
+        MessageUnpin {
+            message: String,
+            author: String,
+            channel: String,
+        },
+        BanCreate {
+            user: String,
+        },
+        BanDelete {
+            user: String,
+        },
+        ChannelCreate {
+            channel: String,
+            name: String,
+        },
+        ChannelEdit {
+            channel: String,
+            before: PartialChannel,
+            after: PartialChannel,
+        },
+        ChannelRolePermissionsEdit {
+            channel: String,
+            role: String,
+            permissions: OverrideField,
+        },
+        ChannelDelete {
+            channel: String,
+            name: String,
+        },
+        MemberEdit {
+            user: String,
+            before: PartialMember,
+            after: PartialMember,
+        },
+        MemberKick {
+            user: String,
+        },
+        ServerEdit {
+            before: PartialServer,
+            after: PartialServer,
+        },
+        RoleEdit {
+            role: String,
+            before: PartialRole,
+            after: PartialRole,
+        },
+        RoleCreate {
+            role: String,
+            name: String,
+        },
+        RoleDelete {
+            role: String,
+            name: String,
+        },
+        RolesReorder {
+            before: Vec<String>,
+            after: Vec<String>,
+        },
+        InviteCreate {
+            invite: String,
+            channel: String,
+        },
+        InviteDelete {
+            invite: String,
+            channel: String,
+        },
+        WebhookCreate {
+            webhook: String,
+            name: String,
+            channel: String,
+        },
+        WebhookDelete {
+            webhook: String,
+            name: String,
+            channel: String,
+        },
+        EmojiCreate {
+            emoji: String,
+            name: String,
+        },
+        EmojiUpdate {
+            emoji: String,
+            before: PartialEmoji,
+            after: PartialEmoji,
+        },
+        EmojiDelete {
+            emoji: String,
+            name: String,
+        },
+    }
+
+    /// Audit Log Query
+    pub struct AuditLogQuery {
+        /// Filter by who ran the action
+        pub user: Option<String>,
+        /// Filter by who the action is targetting
+        pub target: Option<String>,
+        /// Filter by the action type
+        pub r#type: Option<Vec<String>>,
+        /// Entries before a certain entry id
+        pub before: Option<String>,
+        /// Entries after a certain entry id
+        pub after: Option<String>,
+        /// Maximum number of entries to fetch
+        pub limit: i64,
+    }
+);
+
+impl AuditLogEntryAction {
+    // TODO: migrate this to a rabbitmq queue to avoid spawning lots of tasks
+    /// Generates an `AuditLogEntry` for the current action and inserts it into the database
+    pub async fn insert<R: Into<Option<String>>>(
+        self,
+        db: &Database,
+        server: String,
+        reason: R,
+        user: String,
+        target: Option<String>,
+    ) -> AuditLogEntry {
+        let config = config().await;
+
+        let id = Ulid::new();
+        let expires_at = id
+            .datetime()
+            .checked_add(Duration::from_secs(config.api.audit_logs.expires_after))
+            .unwrap()
+            .into();
+
+        let entry = AuditLogEntry {
+            id: id.to_string(),
+            expires_at,
+            server,
+            reason: reason.into(),
+            user,
+            target,
+            action: self,
+        };
+
+        // running the insert inside a task can cause race conditions in the test so for now just dont use a task for tests for now
+        // this will need to be redone for when we migrate to using rabbitmq here anyway.
+        #[cfg(not(test))]
+        tokio::task::spawn({
+            let db = db.clone();
+            let entry = entry.clone();
+
+            async move { revolt_config::report_internal_error!(db.insert_audit_log_entry(&entry).await) }
+        });
+
+        #[cfg(test)]
+        db.insert_audit_log_entry(&entry).await.unwrap();
+
+        entry
+    }
+}
+
+impl AuditLogEntry {
+    /// Fetches the corrasponding users and members for each audit log entry
+    pub async fn with_users(
+        db: &Database,
+        server_id: &str,
+        user: &User,
+        entries: &[Self],
+    ) -> Result<(Vec<v0::User>, Vec<v0::Member>)> {
+        let mut user_ids = HashSet::new();
+
+        for entry in entries {
+            user_ids.insert(entry.user.clone());
+
+            match &entry.action {
+                AuditLogEntryAction::MessageDelete { author, .. } => {
+                    user_ids.insert(author.clone());
+                }
+                AuditLogEntryAction::BanCreate { user } => {
+                    user_ids.insert(user.clone());
+                }
+                AuditLogEntryAction::BanDelete { user } => {
+                    user_ids.insert(user.clone());
+                }
+                AuditLogEntryAction::ChannelCreate { .. } => {}
+                AuditLogEntryAction::MemberEdit { user, .. } => {
+                    user_ids.insert(user.clone());
+                }
+                AuditLogEntryAction::MemberKick { user } => {
+                    user_ids.insert(user.clone());
+                }
+                AuditLogEntryAction::MessagePin { author, .. } => {
+                    user_ids.insert(author.clone());
+                }
+                AuditLogEntryAction::MessageUnpin { author, .. } => {
+                    user_ids.insert(author.clone());
+                }
+                AuditLogEntryAction::ServerEdit { .. } => {}
+                AuditLogEntryAction::RoleEdit { .. } => {}
+                AuditLogEntryAction::RoleCreate { .. } => {}
+                AuditLogEntryAction::RoleDelete { .. } => {}
+                AuditLogEntryAction::RolesReorder { .. } => {}
+                AuditLogEntryAction::MessageBulkDelete { .. } => {}
+                AuditLogEntryAction::ChannelEdit { .. } => {}
+                AuditLogEntryAction::ChannelRolePermissionsEdit { .. } => {}
+                AuditLogEntryAction::ChannelDelete { .. } => {}
+                AuditLogEntryAction::InviteCreate { .. } => {}
+                AuditLogEntryAction::InviteDelete { .. } => {}
+                AuditLogEntryAction::WebhookCreate { .. } => {}
+                AuditLogEntryAction::WebhookDelete { .. } => {}
+                AuditLogEntryAction::EmojiCreate { .. } => {}
+                AuditLogEntryAction::EmojiUpdate { .. } => {}
+                AuditLogEntryAction::EmojiDelete { .. } => {}
+            };
+        }
+
+        let user_ids = user_ids.into_iter().collect::<Vec<_>>();
+
+        let users = User::fetch_many_ids_as_mutuals(db, user, &user_ids).await?;
+        let members = db
+            .fetch_members(server_id, &user_ids)
+            .await?
+            .into_iter()
+            .map(Into::into)
+            .collect();
+
+        Ok((users, members))
+    }
+}

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

@@ -0,0 +1,20 @@
+use revolt_result::Result;
+
+use crate::{AuditLogEntry, AuditLogQuery};
+
+#[cfg(feature = "mongodb")]
+mod mongodb;
+mod reference;
+
+#[async_trait]
+pub trait AbstractAuditLogs: Sync + Send {
+    /// Inserts an entry into the server's audit log
+    async fn insert_audit_log_entry(&self, entry: &AuditLogEntry) -> Result<()>;
+
+    /// Fetches a server's audit logs using the provided query options
+    async fn get_server_audit_logs(
+        &self,
+        server: &str,
+        query: AuditLogQuery,
+    ) -> Result<Vec<AuditLogEntry>>;
+}

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

@@ -0,0 +1,66 @@
+use mongodb::options::FindOptions;
+use revolt_result::Result;
+
+use crate::{AuditLogEntry, AuditLogQuery, MongoDb};
+
+use super::AbstractAuditLogs;
+
+static COL: &str = "audit_logs";
+
+#[async_trait]
+impl AbstractAuditLogs for MongoDb {
+    /// Inserts an entry into the server's audit log
+    async fn insert_audit_log_entry(&self, entry: &AuditLogEntry) -> Result<()> {
+        query!(self, insert_one, COL, entry).map(|_| ())
+    }
+
+    /// Fetches a server's audit logs using the provided query options
+    async fn get_server_audit_logs(
+        &self,
+        server: &str,
+        query: AuditLogQuery,
+    ) -> Result<Vec<AuditLogEntry>> {
+        let mut filter = doc! {
+            "server": server
+        };
+
+        if let Some(user) = query.user {
+            filter.insert("user", user);
+        };
+
+        if let Some(target) = query.target {
+            filter.insert("target", target);
+        }
+
+        if let Some(types) = query.r#type {
+            filter.insert("action.type", doc! { "$in": types });
+        };
+
+        if let Some(doc) = match (query.before, query.after) {
+            (Some(before), Some(after)) => Some(doc! {
+                "$lt": before,
+                "$gt": after
+            }),
+            (Some(before), _) => Some(doc! {
+                "$lt": before
+            }),
+            (_, Some(after)) => Some(doc! {
+                "$gt": after
+            }),
+            _ => None,
+        } {
+            filter.insert("_id", doc);
+        };
+
+        self.find_with_options(
+            COL,
+            filter,
+            FindOptions::builder()
+                .limit(query.limit)
+                .sort(doc! { "_id": -1 })
+                .build(),
+        )
+        .await
+        .map_err(|_| create_database_error!("find", COL))
+    }
+}

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

@@ -0,0 +1,81 @@
+use revolt_result::Result;
+
+use crate::{AuditLogEntry, AuditLogQuery, ReferenceDb};
+
+use super::AbstractAuditLogs;
+
+#[async_trait]
+impl AbstractAuditLogs for ReferenceDb {
+    /// Inserts an entry into the server's audit log
+    async fn insert_audit_log_entry(&self, entry: &AuditLogEntry) -> Result<()> {
+        self.audit_logs
+            .lock()
+            .await
+            .insert(entry.id.clone(), entry.clone());
+
+        Ok(())
+    }
+
+    /// Fetches a server's audit logs using the provided query options
+    async fn get_server_audit_logs(
+        &self,
+        server: &str,
+        query: AuditLogQuery,
+    ) -> Result<Vec<AuditLogEntry>> {
+        let lock = self.audit_logs.lock().await;
+
+        let mut logs = lock
+            .values()
+            .filter(|entry| {
+                if entry.server != server {
+                    return false;
+                };
+
+                if let Some(user) = &query.user {
+                    if &entry.user != user {
+                        return false;
+                    }
+                }
+
+                if query.target.is_some() && entry.target != query.target {
+                    return false;
+                }
+
+                if let Some(before) = &query.before {
+                    if &entry.id > before {
+                        return false;
+                    };
+                };
+
+                if let Some(after) = &query.after {
+                    if &entry.id < after {
+                        return false;
+                    };
+                };
+
+                if let Some(action_types) = &query.r#type {
+                    let entry_type = serde_json::to_value(entry.action.clone())
+                        .unwrap()
+                        .as_object()
+                        .unwrap()
+                        .get("type")
+                        .unwrap()
+                        .as_str()
+                        .unwrap()
+                        .to_string();
+
+                    if !action_types.contains(&entry_type) {
+                        return false;
+                    }
+                };
+
+                true
+            })
+            .cloned()
+            .collect::<Vec<_>>();
+
+        logs.sort_by(|a, b| b.id.cmp(&a.id));
+        logs.truncate(query.limit as usize);
+        Ok(logs)
+    }
+}

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

@@ -164,7 +164,7 @@ impl Bot {
 mod tests {
     use crate::{Bot, FieldsBot, PartialBot, User};
 
-    #[async_std::test]
+    #[tokio::test]
     async fn crud() {
         database_test!(|db| async move {
             let owner = User::create(&db, "Owner".to_string(), None, None)

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

@@ -69,7 +69,7 @@ impl Invite {
                 creator: creator.id.clone(),
                 channel: id.clone(),
             }),
-            Channel::TextChannel { id, server, .. } | Channel::VoiceChannel { id, server, .. } => {
+            Channel::TextChannel { id, server, .. } => {
                 Ok(Invite::Server {
                     code,
                     creator: creator.id.clone(),

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

@@ -128,7 +128,7 @@ impl Webhook {
 mod tests {
     use crate::{FieldsWebhook, PartialWebhook, Webhook};
 
-    #[async_std::test]
+    #[tokio::test]
     async fn crud() {
         database_test!(|db| async move {
             let webhook_id = "webhook";

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

@@ -1,5 +1,7 @@
-use std::collections::HashMap;
+#![allow(deprecated)]
+use std::{borrow::Cow, collections::HashMap};
 
+use redis_kiss::get_connection;
 use revolt_config::config;
 use revolt_models::v0::{self, MessageAuthor};
 use revolt_permissions::OverrideField;
@@ -8,8 +10,7 @@ use serde::{Deserialize, Serialize};
 use ulid::Ulid;
 
 use crate::{
-    events::client::EventV1, Database, File, PartialServer,
-    Server, SystemMessage, User, AMQP,
+    events::client::EventV1, Database, File, PartialServer, Server, SystemMessage, User, AMQP,
 };
 
 #[cfg(feature = "mongodb")]
@@ -106,38 +107,22 @@ auto_derived!(
             /// Whether this channel is marked as not safe for work
             #[serde(skip_serializing_if = "crate::if_false", default)]
             nsfw: bool,
+
+            /// Voice Information for when this channel is also a voice channel
+            #[serde(skip_serializing_if = "Option::is_none")]
+            voice: Option<VoiceInformation>,
+
+            /// The channel's slowmode delay in seconds
+            #[serde(skip_serializing_if = "Option::is_none")]
+            slowmode: Option<u64>,
         },
-        /// Voice channel belonging to a server
-        VoiceChannel {
-            /// Unique Id
-            #[serde(rename = "_id")]
-            id: String,
-            /// Id of the server this channel belongs to
-            server: String,
+    }
 
-            /// Display name of the channel
-            name: String,
-            #[serde(skip_serializing_if = "Option::is_none")]
-            /// Channel description
-            description: Option<String>,
-            /// Custom icon attachment
-            #[serde(skip_serializing_if = "Option::is_none")]
-            icon: Option<File>,
-
-            /// Default permissions assigned to users in this channel
-            #[serde(skip_serializing_if = "Option::is_none")]
-            default_permissions: Option<OverrideField>,
-            /// Permissions assigned based on role to this channel
-            #[serde(
-                default = "HashMap::<String, OverrideField>::new",
-                skip_serializing_if = "HashMap::<String, OverrideField>::is_empty"
-            )]
-            role_permissions: HashMap<String, OverrideField>,
-
-            /// Whether this channel is marked as not safe for work
-            #[serde(skip_serializing_if = "crate::if_false", default)]
-            nsfw: bool,
-        },
+    #[derive(Default)]
+    pub struct VoiceInformation {
+        /// Maximium amount of users allowed in the voice channel at once
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub max_users: Option<usize>,
     }
 );
 
@@ -164,6 +149,10 @@ auto_derived!(
         pub default_permissions: Option<OverrideField>,
         #[serde(skip_serializing_if = "Option::is_none")]
         pub last_message_id: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub voice: Option<VoiceInformation>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub slowmode: Option<u64>,
     }
 
     /// Optional fields on channel object
@@ -171,6 +160,7 @@ auto_derived!(
         Description,
         Icon,
         DefaultPermissions,
+        Voice,
     }
 );
 
@@ -222,16 +212,21 @@ impl Channel {
                 default_permissions: None,
                 role_permissions: HashMap::new(),
                 nsfw: data.nsfw.unwrap_or(false),
+                voice: data.voice.map(|voice| voice.into()),
+                slowmode: None,
             },
-            v0::LegacyServerChannelType::Voice => Channel::VoiceChannel {
+            v0::LegacyServerChannelType::Voice => Channel::TextChannel {
                 id: id.clone(),
                 server: server.id.to_owned(),
                 name: data.name,
                 description: data.description,
                 icon: None,
+                last_message_id: None,
                 default_permissions: None,
                 role_permissions: HashMap::new(),
                 nsfw: data.nsfw.unwrap_or(false),
+                voice: Some(data.voice.unwrap_or_default().into()),
+                slowmode: None,
             },
         };
 
@@ -413,7 +408,10 @@ impl Channel {
     /// Check whether has a user as a recipient
     pub fn contains_user(&self, user_id: &str) -> bool {
         match self {
-            Channel::Group { recipients, .. } => recipients.contains(&String::from(user_id)),
+            Channel::Group { recipients, .. } | Channel::DirectMessage { recipients, .. } => {
+                recipients.iter().any(|recipient| recipient == user_id)
+            }
+            Channel::SavedMessages { user, .. } => user == user_id,
             _ => false,
         }
     }
@@ -421,7 +419,9 @@ impl Channel {
     /// Get list of recipients
     pub fn users(&self) -> Result<Vec<String>> {
         match self {
-            Channel::Group { recipients, .. } => Ok(recipients.to_owned()),
+            Channel::Group { recipients, .. } | Channel::DirectMessage { recipients, .. } => {
+                Ok(recipients.to_owned())
+            }
             _ => Err(create_error!(NotFound)),
         }
     }
@@ -432,8 +432,28 @@ impl Channel {
             Channel::DirectMessage { id, .. }
             | Channel::Group { id, .. }
             | Channel::SavedMessages { id, .. }
-            | Channel::TextChannel { id, .. }
-            | Channel::VoiceChannel { id, .. } => id,
+            | Channel::TextChannel { id, .. } => id,
+        }
+    }
+
+    /// Clone this channel's server id
+    pub fn server(&self) -> Option<&str> {
+        match self {
+            Channel::TextChannel { server, .. } => Some(server),
+            _ => None,
+        }
+    }
+
+    /// Gets this channel's voice information
+    pub fn voice(&self) -> Option<Cow<VoiceInformation>> {
+        match self {
+            Self::DirectMessage { .. } | Self::Group { .. } => {
+                Some(Cow::Owned(VoiceInformation::default()))
+            }
+            Self::TextChannel {
+                voice: Some(voice), ..
+            } => Some(Cow::Borrowed(voice)),
+            _ => None,
         }
     }
 
@@ -450,12 +470,6 @@ impl Channel {
                 server,
                 role_permissions,
                 ..
-            }
-            | Channel::VoiceChannel {
-                id,
-                server,
-                role_permissions,
-                ..
             } => {
                 db.set_channel_role_permission(id, role_id, permissions)
                     .await?;
@@ -502,7 +516,7 @@ impl Channel {
             clear: remove.into_iter().map(|v| v.into()).collect(),
         }
         .p(match self {
-            Self::TextChannel { server, .. } | Self::VoiceChannel { server, .. } => server.clone(),
+            Self::TextChannel { server, .. } => server.clone(),
             _ => id,
         })
         .await;
@@ -514,17 +528,13 @@ impl Channel {
     pub fn remove_field(&mut self, field: &FieldsChannel) {
         match field {
             FieldsChannel::Description => match self {
-                Self::Group { description, .. }
-                | Self::TextChannel { description, .. }
-                | Self::VoiceChannel { description, .. } => {
+                Self::Group { description, .. } | Self::TextChannel { description, .. } => {
                     description.take();
                 }
                 _ => {}
             },
             FieldsChannel::Icon => match self {
-                Self::Group { icon, .. }
-                | Self::TextChannel { icon, .. }
-                | Self::VoiceChannel { icon, .. } => {
+                Self::Group { icon, .. } | Self::TextChannel { icon, .. } => {
                     icon.take();
                 }
                 _ => {}
@@ -533,15 +543,17 @@ impl Channel {
                 Self::TextChannel {
                     default_permissions,
                     ..
-                }
-                | Self::VoiceChannel {
-                    default_permissions,
-                    ..
                 } => {
                     default_permissions.take();
                 }
                 _ => {}
             },
+            FieldsChannel::Voice => match self {
+                Self::TextChannel { voice, .. } => {
+                    voice.take();
+                }
+                _ => {}
+            },
         }
     }
 
@@ -553,6 +565,7 @@ impl Channel {
     }
 
     /// Apply partial channel to channel
+    #[allow(deprecated)]
     pub fn apply_options(&mut self, partial: PartialChannel) {
         match self {
             Self::SavedMessages { .. } => {}
@@ -601,15 +614,7 @@ impl Channel {
                 nsfw,
                 default_permissions,
                 role_permissions,
-                ..
-            }
-            | Self::VoiceChannel {
-                name,
-                description,
-                icon,
-                nsfw,
-                default_permissions,
-                role_permissions,
+                voice,
                 ..
             } => {
                 if let Some(v) = partial.name {
@@ -635,12 +640,132 @@ impl Channel {
                 if let Some(v) = partial.default_permissions {
                     default_permissions.replace(v);
                 }
+
+                if let Some(v) = partial.voice {
+                    voice.replace(v);
+                }
             }
         }
     }
 
+    /// Generates a PartialChannel containing the data which has changed in an update
+    pub fn generate_diff(
+        &self,
+        partial: &PartialChannel,
+        remove: &[FieldsChannel],
+    ) -> PartialChannel {
+        let mut before = PartialChannel::default();
+
+        match self {
+            Channel::SavedMessages { .. } => {}
+            Channel::DirectMessage {
+                active,
+                last_message_id,
+                ..
+            } => {
+                if partial.active.is_some() {
+                    before.active = Some(*active);
+                };
+
+                if partial.last_message_id.is_some() {
+                    before.last_message_id = last_message_id.clone()
+                };
+            }
+            Channel::Group {
+                name,
+                owner,
+                description,
+                icon,
+                last_message_id,
+                permissions,
+                nsfw,
+                ..
+            } => {
+                if partial.name.is_some() {
+                    before.name = Some(name.clone());
+                };
+
+                if partial.owner.is_some() {
+                    before.owner = Some(owner.clone());
+                };
+
+                if partial.description.is_some() || remove.contains(&FieldsChannel::Description) {
+                    before.description = description.clone();
+                };
+
+                if partial.icon.is_some() || remove.contains(&FieldsChannel::Icon) {
+                    before.icon = icon.clone();
+                };
+
+                if partial.last_message_id.is_some() {
+                    before.last_message_id = last_message_id.clone()
+                };
+
+                if partial.permissions.is_some() {
+                    before.permissions = *permissions;
+                };
+
+                if partial.nsfw.is_some() {
+                    before.nsfw = Some(*nsfw);
+                };
+            }
+            Channel::TextChannel {
+                name,
+                description,
+                icon,
+                last_message_id,
+                default_permissions,
+                role_permissions,
+                nsfw,
+                voice,
+                slowmode,
+                ..
+            } => {
+                if partial.name.is_some() {
+                    before.name = Some(name.clone());
+                };
+
+                if partial.description.is_some() || remove.contains(&FieldsChannel::Description) {
+                    before.description = description.clone();
+                };
+
+                if partial.icon.is_some() || remove.contains(&FieldsChannel::Icon) {
+                    before.icon = icon.clone();
+                };
+
+                if partial.last_message_id.is_some() {
+                    before.last_message_id = last_message_id.clone()
+                };
+
+                if partial.default_permissions.is_some()
+                    || remove.contains(&FieldsChannel::DefaultPermissions)
+                {
+                    before.default_permissions = *default_permissions;
+                };
+
+                if partial.role_permissions.is_some() {
+                    before.role_permissions = Some(role_permissions.clone());
+                };
+
+                if partial.nsfw.is_some() {
+                    before.nsfw = Some(*nsfw);
+                };
+
+                if partial.voice.is_some() || remove.contains(&FieldsChannel::Voice) {
+                    before.voice = voice.clone();
+                };
+
+                if partial.slowmode.is_some() {
+                    before.slowmode = *slowmode;
+                }
+            }
+        }
+
+        before
+    }
+
     /// Acknowledge a message
-    pub async fn ack(&self, user: &str, message: &str) -> Result<()> {
+    pub async fn ack(&self, user: &str, message: &str, amqp: &AMQP) -> Result<()> {
         EventV1::ChannelAck {
             id: self.id().to_string(),
             user: user.to_string(),
@@ -649,17 +774,7 @@ 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 {
-                id: message.to_string(),
-            },
-        )
-        .await;
-
-        Ok(())
+        crate::util::acker::ack_channel(user, self.id(), message, amqp).await
     }
 
     /// Remove user from a group
@@ -777,6 +892,7 @@ impl IntoDocumentPath for FieldsChannel {
             FieldsChannel::Description => "description",
             FieldsChannel::Icon => "icon",
             FieldsChannel::DefaultPermissions => "default_permissions",
+            FieldsChannel::Voice => "voice",
         })
     }
 }
@@ -787,7 +903,7 @@ mod tests {
 
     use crate::{fixture, util::permissions::DatabasePermissionQuery};
 
-    #[async_std::test]
+    #[tokio::test]
     async fn permissions_group_channel() {
         database_test!(|db| async move {
             fixture!(db, "group_with_members",
@@ -813,7 +929,7 @@ mod tests {
         });
     }
 
-    #[async_std::test]
+    #[tokio::test]
     async fn permissions_text_channel() {
         database_test!(|db| async move {
             fixture!(db, "server_with_roles",

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

@@ -1,4 +1,4 @@
-use crate::{revolt_result::Result, Channel, FieldsChannel, PartialChannel};
+use crate::{Channel, FieldsChannel, PartialChannel, revolt_result::Result, util::ChunkedDatabaseGenerator};
 use revolt_permissions::OverrideField;
 
 #[cfg(feature = "mongodb")]
@@ -19,6 +19,9 @@ pub trait AbstractChannels: Sync + Send {
     /// Fetch all direct messages for a user
     async fn find_direct_messages(&self, user_id: &str) -> Result<Vec<Channel>>;
 
+    // Fetch all group dms for a user
+    async fn find_group_message_channels(&self, user_id: &str) -> Result<ChunkedDatabaseGenerator<Channel>>;
+
     // Fetch saved messages channel
     async fn find_saved_messages_channel(&self, user_id: &str) -> Result<Channel>;
 
@@ -47,6 +50,9 @@ pub trait AbstractChannels: Sync + Send {
     // Remove a user from a group
     async fn remove_user_from_group(&self, channel_id: &str, user_id: &str) -> Result<()>;
 
+    // Remove a user from all specified groups
+    async fn remove_user_from_groups(&self, channel_ids: Vec<String>, user_id: &str) -> Result<()>;
+
     // Delete a channel
     async fn delete_channel(&self, channel_id: &Channel) -> Result<()>;
 }

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

@@ -1,7 +1,8 @@
 use super::AbstractChannels;
-use crate::{AbstractServers, Channel, FieldsChannel, IntoDocumentPath, MongoDb, PartialChannel};
+use crate::{AbstractServers, Channel, FieldsChannel, IntoDocumentPath, MongoDb, PartialChannel, util::ChunkedDatabaseGenerator};
 use bson::{Bson, Document};
 use futures::StreamExt;
+use mongodb::options::ReadConcern;
 use revolt_permissions::OverrideField;
 use revolt_result::Result;
 
@@ -69,6 +70,32 @@ impl AbstractChannels for MongoDb {
         )
     }
 
+    // Fetch all group dms for a user
+    async fn find_group_message_channels(&self, user_id: &str) -> Result<ChunkedDatabaseGenerator<Channel>> {
+        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(COL)
+            .find(doc! {
+                "channel_type": "Group",
+                "recipients": user_id
+            })
+            .session(&mut session)
+            .batch_size(100)
+            .await
+            .map_err(|_| create_database_error!("find", COL))?;
+
+        Ok(ChunkedDatabaseGenerator::new_mongo(session, cursor))
+    }
+
     // Fetch saved messages channel
     async fn find_saved_messages_channel(&self, user_id: &str) -> Result<Channel> {
         query!(
@@ -180,13 +207,29 @@ impl AbstractChannels for MongoDb {
             .map_err(|_| create_database_error!("update_one", "channels"))
     }
 
+    // Remove a user from all specified groups
+    async fn remove_user_from_groups(&self, channel_ids: Vec<String>, user_id: &str) -> Result<()> {
+        self.col::<Document>(COL)
+            .update_many(
+                doc! {
+                    "_id": { "$in": channel_ids },
+                },
+                doc! {
+                    "$pull": {
+                        "recipients": user_id
+                    }
+                },
+            )
+            .await
+            .map(|_| ())
+            .map_err(|_| create_database_error!("update_many", COL))
+    }
+
     // Delete a channel
     async fn delete_channel(&self, channel: &Channel) -> Result<()> {
         let id = channel.id().to_string();
         let server_id = match channel {
-            Channel::TextChannel { server, .. } | Channel::VoiceChannel { server, .. } => {
-                Some(server)
-            }
+            Channel::TextChannel { server, .. } => Some(server),
             _ => None,
         };