Merge branch 'main' into feat/oauth2

chore: sync branch with main
refactor: simplify scope struct macro
2025-11-03 03:28:19 +00:00 · 2025-08-18 02:14:36 +01:00 · 2025-08-18 01:58:15 +01:00 · 2025-08-18 01:58:15 +01:00 · 2025-08-18 01:58:15 +01:00 · 2025-08-18 01:58:15 +01:00
294 changed files with 3541 additions and 38722 deletions
@@ -1,147 +0,0 @@
-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.
@@ -0,0 +1,37 @@
+name: Build documentation
+on:
+  push:
+    branches:
+      - main
+
+jobs:
+  deploy:
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write # To push a branch
+      pages: write # To push to a GitHub Pages site
+      id-token: write # To update the deployment status
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - name: Install latest mdbook
+        run: |
+          tag=$(curl 'https://api.github.com/repos/rust-lang/mdbook/releases/latest' | jq -r '.tag_name')
+          url="https://github.com/rust-lang/mdbook/releases/download/${tag}/mdbook-${tag}-x86_64-unknown-linux-gnu.tar.gz"
+          mkdir mdbook
+          curl -sSL $url | tar -xz --directory=./mdbook
+          echo `pwd`/mdbook >> $GITHUB_PATH
+      - name: Build Book
+        run: |
+          cd doc
+          mdbook build
+      - name: Setup Pages
+        uses: actions/configure-pages@v4
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: "doc/book"
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4
@@ -5,22 +5,19 @@ 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: arc-runner-set
+    runs-on: ubuntu-latest
    if: github.event_name == 'pull_request'
    steps:
      # Configure build environment
@@ -41,7 +38,7 @@ jobs:
          cache-to: type=gha,scope=buildx-base-multi-arch,mode=max

  publish:
-    runs-on: arc-runner-set
+    runs-on: self-hosted
    if: github.event_name != 'pull_request'
    name: Publish Docker images
    steps:
@@ -200,22 +197,3 @@ jobs:
          build-args: |
            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
          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:latest
-          labels: ${{ steps.meta-voice-ingress.outputs.labels }}
@@ -1,23 +0,0 @@
-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
@@ -1,48 +0,0 @@
-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
@@ -1,23 +0,0 @@
-# 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
@@ -1,24 +0,0 @@
-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
-        run: mise publish --workspace
@@ -1,63 +0,0 @@
-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
@@ -1,26 +0,0 @@
-# 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\"}"
@@ -2,12 +2,16 @@ name: Rust build, test, and generate specification

 on:
  push:
-    branches: [main]
+    paths-ignore:
+      - ".github/**"
+      - "!.github/workflows/rust.yaml"
+      - ".vscode/**"
+      - "doc/**"
+      - ".gitignore"
+      - "LICENSE"
+      - "README"
  pull_request:
-
-concurrency:
-  group: ${{ github.head_ref || github.ref }}
-  cancel-in-progress: true
+    branches: [main]

 env:
  CARGO_TERM_COLOR: always
@@ -15,58 +19,63 @@ env:
 jobs:
  check:
    name: Rust project
-    runs-on: arc-runner-set
+    runs-on: ubuntu-latest
    steps:
-      - uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+      - uses: actions/checkout@v2
+      - name: Install latest stable
+        uses: actions-rs/toolchain@v1
        with:
-          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
+          toolchain: stable
+          override: true
+          components: rustfmt, clippy
+      - name: Install cargo-nextest
+        uses: baptiste0928/cargo-install@v1
        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
+          crate: cargo-nextest
+          locked: true

-      - run: mise build
-      - run: mise docker:start
-    
-      - name: Reference Test
+      - name: Run cargo build
+        uses: actions-rs/cargo@v1
+        with:
+          command: build
+
+      - name: Run services in background
+        run: |
+          docker compose -f compose.yml up -d
+
+      - name: Run cargo test
        env:
          TEST_DB: REFERENCE
        run: |
-          mise test
+          cargo nextest run

-      - name: MongoDB Test
+      - name: Run cargo test (with MongoDB)
        env:
          TEST_DB: MONGODB
          MONGODB: mongodb://localhost
        run: |
-          mise test
+          cargo nextest run

      - name: Start API in background
        if: github.event_name != 'pull_request' && github.ref_name == 'main'
        env:
          TEST_DB: REFERENCE
        run: |
-          mise build --bin revolt-delta && (mise service:api &)
+          cargo build --bin revolt-delta && (cargo run --bin revolt-delta &)

      - name: Wait for API to go up
        if: github.event_name != 'pull_request' && github.ref_name == 'main'
-        uses: nev7n/wait_for_response@7fef3c1a6e8939d0b09062f14fec50d3c5d15fa1 # v1.0.1
+        uses: nev7n/wait_for_response@v1
        with:
          url: "http://localhost:14702/"

      - name: Checkout API repository
        if: github.event_name != 'pull_request' && github.ref_name == 'main'
-        uses: actions/checkout@8e8c483db84b4bee98b60c0593521ed34d9990e8 # v6.0.1
+        uses: actions/checkout@v3
        with:
-          repository: stoatchat/javascript-client-api
+          repository: stoatchat/api
          path: api
-          ssh-key: ${{ secrets.DEPLOY_KEY_JAVASCRIPT_CLIENT_API }}
+          token: ${{ secrets.PAT }}

      - name: Download OpenAPI specification
        if: github.event_name != 'pull_request' && github.ref_name == 'main'
@@ -74,10 +83,10 @@ jobs:

      - name: Commit changes
        if: github.event_name != 'pull_request' && github.ref_name == 'main'
-        uses: EndBug/add-and-commit@a94899bca583c204427a224a7af87c02f9b325d5 # v9.1.4
+        uses: EndBug/add-and-commit@v4
        with:
          cwd: "api"
          add: "*.json"
-          author_name: Stoat CI
-          author_email: stoat-ci@users.noreply.github.com
+          author_name: Revolt CI
+          author_email: revolt-ci@users.noreply.github.com
          message: "chore: generate OpenAPI specification"
@@ -0,0 +1,54 @@
+name: Add Issue to Board
+
+on:
+  issues:
+    types: [opened]
+
+jobs:
+  track_issue:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get project data
+        env:
+          GITHUB_TOKEN: ${{ secrets.PAT }}
+        run: |
+          gh api graphql -f query='
+            query {
+              organization(login: "stoatchat"){
+                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
@@ -0,0 +1,79 @@
+name: Add PR to Board
+
+on:
+  pull_request_target:
+    types: [opened, synchronize, ready_for_review, review_requested]
+
+jobs:
+  track_pr:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get project data
+        env:
+          GITHUB_TOKEN: ${{ secrets.PAT }}
+        run: |
+          gh api graphql -f query='
+            query {
+              organization(login: "stoatchat"){
+                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
@@ -1,23 +0,0 @@
-# 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 }}
@@ -11,5 +11,4 @@ venv/
 .vercel
 .DS_Store

-livekit.yml
 .idea
@@ -1,19 +0,0 @@
-[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"]
-run = [{ task = "service:*" }]
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Build project"
-set -e
-
-cargo build "$@"
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Check project with clippy"
-set -e
-
-cargo clippy
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Start Docker containers"
-set -e
-
-docker compose up -d
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Stop Docker containers"
-set -e
-
-docker compose down
@@ -1,7 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Start the Stoat Developers website"
-#MISE depends=["docs:install"]
-#MISE dir="{{config_root}}/docs"
-set -e
-
-pnpm build
@@ -1,7 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Build the Stoat Developers website"
-#MISE depends=["docs:install"]
-#MISE dir="{{config_root}}/docs"
-set -e
-
-pnpm build
@@ -1,6 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Install dependencies for docs site"
-#MISE dir="{{config_root}}/docs"
-set -e
-
-pnpm i --frozen-lockfile
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Publish project"
-set -e
-
-cargo publish "$@"
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Run API server"
-set -e
-
-cargo run --bin revolt-delta
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Run cron daemon"
-set -e
-
-cargo run --bin revolt-crond
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Run events server"
-set -e
-
-cargo run --bin revolt-bonfire
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Run file server"
-set -e
-
-cargo run --bin revolt-autumn
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Run GIF proxy server"
-set -e
-
-cargo run --bin revolt-gifbox
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Run proxy server"
-set -e
-
-cargo run --bin revolt-january
@@ -1,5 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Run push daemon"
-set -e
-
-cargo run --bin revolt-pushd
@@ -1,8 +0,0 @@
-#!/usr/bin/env bash
-#MISE description="Test project"
-set -e
-
-: "${TEST_DB:=REFERENCE}"
-export TEST_DB
-
-cargo nextest run
@@ -1,3 +0,0 @@
-{
-    ".": "0.11.5"
-}
@@ -1,149 +0,0 @@
-# Changelog
-
-## [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` -&gt; `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))
@@ -14,37 +14,9 @@ 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 = { version = "1.49.0", features = ["macros", "rt"] }
-
-# Error Handling
-anyhow = "1.0.100"
-thiserror = "2.0.18"
-
-# Other Utilities
-uuid = { version = "1.19.0", features = ["v4"] }
-
-# Axum (HTTP server)
-axum-macros = "0.4.1"
-axum_typed_multipart = "0.12.1"
-axum = { version = "0.7.5", features = ["multipart"] }
-tower-http = { version = "0.5.2", features = ["cors", "trace"] }
-
-# Image Processing
-jxl-oxide = { version = "0.12.5", features = ["image"] }
-image = "0.25.9"
-
-# 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 = { version = "0.31.1" }
@@ -1,5 +1,5 @@
 # Build Stage
-FROM --platform="${BUILDPLATFORM}" rust:1.92.0-slim-bookworm
+FROM --platform="${BUILDPLATFORM}" rust:1.86.0-slim-bookworm
 USER 0:0
 WORKDIR /home/rust/src

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

@@ -30,7 +30,6 @@ 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
@@ -1,15 +1,15 @@
 <div align="center">
 <h1>
-  Stoat Backend
+  Revolt Backend
  
-  [![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)
+  [![Stars](https://img.shields.io/github/stars/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/stargazers)
+  [![Forks](https://img.shields.io/github/forks/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/network/members)
+  [![Pull Requests](https://img.shields.io/github/issues-pr/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/pulls)
+  [![Issues](https://img.shields.io/github/issues/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/issues)
+  [![Contributors](https://img.shields.io/github/contributors/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/graphs/contributors)
+  [![License](https://img.shields.io/github/license/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/blob/main/LICENSE)
 </h1>
-The services and libraries that power the Stoat service.<br/>
+The services and libraries that power the Revolt service.<br/>
 <br/>

 | Crate              | Path                                               | Description                         |                                                                                                                                                                                                                                                                                                           |
@@ -37,19 +37,22 @@ The services and libraries that power the Stoat 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.stoat.chat/developing/contrib/) and the [technical documentation for this project](https://developers.stoat.chat/).
+Before contributing, make yourself familiar with [our contribution guidelines](https://developers.revolt.chat/contrib.html) and the [technical documentation for this project](https://revoltchat.github.io/backend/).

 Before getting started, you'll want to install:

- mise
+- Rust toolchain (rustup recommended)
 - Docker
 - Git
 - mold (optional, faster compilation)

 > A **default.nix** is available for Nix users!
-> Run `nix-shell` to activate mise.
+> Just run `nix-shell` and continue.

 As a heads-up, the development environment uses the following ports:

@@ -70,10 +73,9 @@ As a heads-up, the development environment uses the following ports:
 Now you can clone and build the project:

 ```bash
-git clone https://github.com/stoatchat/stoatchat stoat-backend
-cd stoat-backend
-mise install
-mise build
+git clone https://github.com/revoltchat/backend revolt-backend
+cd revolt-backend
+cargo build
 ```

 A default configuration `Revolt.toml` is present in this project that is suited for development.
@@ -131,6 +133,9 @@ Then continue:
 # start other necessary services
 docker compose up -d

+# run everything together
+./scripts/start.sh
+# .. or individually
 # run the API server
 cargo run --bin revolt-delta
 # run the events server
@@ -156,11 +161,16 @@ You can start a web client by doing the following:
 corepack enable

 # clone the web client and run it:
-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
+git clone --recursive https://github.com/revoltchat/revite
+cd revite
+yarn
+yarn build:deps
+echo "VITE_API_URL=http://local.revolt.chat:14702" > .env.local
+yarn dev --port 14701
 ```

+Then go to http://local.revolt.chat:14701 to create an account/login.
+
 When signing up, go to http://localhost:14080 to find confirmation/password reset emails.

 ## Deployment Guide
@@ -191,7 +201,7 @@ Tag and push a new release by running:
 just release
 ```

-If you have bumped the crate versions, proceed to [GitHub releases](https://github.com/stoatchat/stoatchat/releases/new) to create a changelog.
+If you have bumped the crate versions, proceed to [GitHub releases](https://github.com/revoltchat/backend/releases/new) to create a changelog.

 ## Testing

@@ -210,6 +220,6 @@ TEST_DB=MONGODB cargo nextest run

 ## License

-The Stoat backend is generally licensed under the [GNU Affero General Public License v3.0](https://github.com/stoatchat/stoatchat/blob/main/LICENSE).
+The Revolt backend is generally licensed under the [GNU Affero General Public License v3.0](https://github.com/revoltchat/backend/blob/master/LICENSE).

 **Individual crates may supply their own licenses!**
@@ -4,7 +4,7 @@
 [database]
 # MongoDB connection URL
 # Defaults to the container name specified in self-hosted
-mongodb = "mongodb://127.0.0.1:27017?directConnection=true&replicaSet=rs0"
+mongodb = "mongodb://127.0.0.1:27017"
 # Redis connection URL
 # Defaults to the container name specified in self-hosted
 redis = "redis://127.0.0.1:6379/"
@@ -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/stoatchat/self-hosted/blob/main/Caddyfile
+# See https://github.com/revoltchat/self-hosted/blob/master/Caddyfile
 #
 # Remember to change these to https/wss where appropriate in production!
 app = "http://local.revolt.chat:14701"
@@ -26,11 +26,6 @@ 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]
@@ -45,17 +40,8 @@ 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"
+[api.security]
+token_secret = "trolt"

 [files.s3]
 # S3 protocol endpoint
@@ -0,0 +1,73 @@
+# Code Style Guide
+
+Beyond using Cargo format and Clippy, there are some specific code style guidelines laid out in this document for different parts of the project.
+
+## Writing Style
+
+- Shorten "identifier" to "Id" with that exact casing, i.e. Server Id.
+
+## `core/database` crate
+
+w.r.t. `model.rs` files
+
+- All struct definitions must be commented.
+  ```rust
+  /// Server
+  pub struct Server {
+    /// Name of the server
+    pub name: String,
+  ```
+- Struct definitions should not include derives unless necessary (if additional traits such as Hash are required) and instead use `auto_derived!` and `auto_derived_partial!`.
+  ```rust
+  auto_derived_partial!(
+    /// Server
+    pub struct Server { .. },
+    "PartialServer"
+  );
+  ```
+- `auto_derived!` macro accepts multiple entries and should be used as such:
+
+  ```rust
+  auto_derived!(
+    /// Optional fields on server object
+    pub enum FieldsServer { .. }
+
+    /// Optional fields on server object
+    pub enum FieldsRole { .. }
+  );
+  ```
+
+- If special serialisation conditions are required, such as checking if a boolean is false, use the existing definitions for these functions from the crate root:
+  ```rust
+  #[serde(skip_serializing_if = "crate::if_false", default)]
+  ```
+- `impl` blocks may be defined below the struct definitions and should be ordered in the same order of definition. Methods in the block must follow the same guidelines as traits where-in: methods are ordered in terms of CRUD, there are empty line breaks, and methods are commented.
+
+w.r.t. `ops` module for models
+
+- All traits must use a the name format `AbstractPlural` where Plural is the plural form of the collection. e.g. Servers
+- Traits defined must follow these guidelines:
+
+  - Methods are ordered in terms of CRUD, create-read-update-delete ordering.
+
+    ```rust
+    #[async_trait]
+    pub trait AbstractServerMembers: Sync + Send {
+      /// Insert a new server member into the database
+      async fn insert_member(&self, member: &Member) -> Result<()>;
+
+      /// Fetch a server member by their id
+      async fn fetch_member(&self, server_id: &str, user_id: &str) -> Result<Member>;
+
+      /// Update information for a server member
+      async fn update_member(&self, .. ) -> Result<()>;
+
+      /// Delete a server member by their id
+      async fn delete_member(&self, id: &MemberCompositeKey) -> Result<()>;
+    }
+    ```
+
+  - There should be an empty line break between each method declaration.
+  - All methods must have an appropriate comment.
+
+- When implementing the trait defined in `ops.rs` with each driver, the method declaration style should be the same for ease of searching: same ordering, same comments, same line breaks.
@@ -8,33 +8,10 @@ services:
  # MongoDB
  database:
    image: mongo
-    command: ["--replSet", "rs0", "--bind_ip_all"]
    ports:
      - "27017:27017"
    volumes:
      - ./.data/db:/data/db
-      - ./scripts/mongo-init.js:/docker-entrypoint-initdb.d/mongo-init.js:ro
-    healthcheck:
-      test: >
-        mongosh --quiet --eval "
-        try {
-          const status = rs.status();
-          if (status.ok === 1 && status.members[0].stateStr === 'PRIMARY') {
-            quit(0);
-          } else {
-            quit(1);
-          }
-        } catch (e) {
-          quit(1);
-        }"
-      interval: 5s
-      timeout: 5s
-      retries: 10
-      start_period: 10s
-    ulimits:
-      nofile:
-        soft: 65536
-        hard: 65536

  # MinIO
  minio:
@@ -63,7 +40,7 @@ services:

  # Rabbit
  rabbit:
-    image: rabbitmq:4-management
+    image: rabbitmq:3-management
    environment:
      RABBITMQ_DEFAULT_USER: rabbituser
      RABBITMQ_DEFAULT_PASS: rabbitpass
@@ -78,7 +55,7 @@ services:

  # Mock SMTP server
  maildev:
-    image: maildev/maildev
+    image: soulteary/maildev
    ports:
      - "14025:25"
      - "14080:8080"
@@ -87,10 +64,3 @@ 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
@@ -1,9 +1,8 @@
 [package]
 name = "revolt-bonfire"
-version = "0.11.5"
+version = "0.8.9"
 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

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

 # core
-authifier = { version = "1.0.16" }
+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", features = ["voice"] }
-revolt-permissions = { path = "../core/permissions" }
+revolt-database = { path = "../core/database" }
+revolt-permissions = { version = "0.8.9", path = "../core/permissions" }
 revolt-presence = { path = "../core/presence", features = ["redis-is-patched"] }

 # redis
@@ -136,7 +136,6 @@ impl handshake::server::Callback for WebsocketHandshakeCallback {
                channels: false,
                members: false,
                emojis: false,
-                voice_states: false,
                user_settings: Vec::new(),
                channel_unreads: false,
                policy_changes: false,
@@ -169,7 +168,6 @@ impl handshake::server::Callback for WebsocketHandshakeCallback {
                                "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) {
@@ -1,10 +1,9 @@
-use std::collections::{HashMap, HashSet};
+use std::collections::HashSet;

 use futures::future::join_all;
 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;
@@ -18,9 +17,8 @@ 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::TextChannel { server, .. } | Channel::VoiceChannel { server, .. } => {
                let member = self.members.get(server);
                let server = self.servers.get(server);
                let mut query =
@@ -124,7 +122,12 @@ impl State {
            .unwrap_or_default();

        // Fetch all memberships with their corresponding servers.
-        let mut members: Vec<Member> = db.fetch_all_memberships(&user.id).await?;
+        let members: Vec<Member> = db.fetch_all_memberships(&user.id).await?;
+        self.cache.members = members
+            .iter()
+            .cloned()
+            .map(|x| (x.id.server.clone(), x))
+            .collect();

        let server_ids: Vec<String> = members.iter().map(|x| x.id.server.clone()).collect();
        let servers = db.fetch_servers(&server_ids).await?;
@@ -153,55 +156,6 @@ 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;

@@ -215,12 +169,6 @@ impl State {
            )
            .await?;

-        self.cache.members = members
-            .iter()
-            .cloned()
-            .map(|x| (x.id.server.clone(), x))
-            .collect();
-
        // Fetch customisations.
        let emojis = if fields.emojis {
            Some(
@@ -320,8 +268,6 @@ impl State {
            } else {
                None
            },
-            voice_states,
-
            emojis,
            user_settings,
            channel_unreads,
@@ -339,14 +285,19 @@ impl State {

            let id = &id.to_string();
            for (channel_id, channel) in &self.cache.channels {
-                if channel.server() == Some(id) {
-                    channel_ids.insert(channel_id.clone());
+                match channel {
+                    Channel::TextChannel { server, .. } | Channel::VoiceChannel { server, .. } => {
+                        if server == id {
+                            channel_ids.insert(channel_id.clone());

-                    if self.cache.can_view_channel(db, channel).await {
-                        added_channels.push(channel_id.clone());
-                    } else {
-                        removed_channels.push(channel_id.clone());
+                            if self.cache.can_view_channel(db, channel).await {
+                                added_channels.push(channel_id.clone());
+                            } else {
+                                removed_channels.push(channel_id.clone());
+                            }
+                        }
                    }
+                    _ => {}
                }
            }

@@ -401,11 +352,6 @@ 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 {
@@ -519,7 +465,6 @@ impl State {
                server,
                channels,
                emojis: _,
-                voice_states: _,
            } => {
                self.insert_subscription(id.clone()).await;

@@ -17,9 +17,11 @@ use redis_kiss::{PayloadType, REDIS_PAYLOAD_TYPE, REDIS_URI};
 use revolt_config::report_internal_error;
 use revolt_database::{
    events::{client::EventV1, server::ClientMessage},
+    util::oauth2,
    iso8601_timestamp::Timestamp,
    Database, User, UserHint,
 };
+use revolt_models::v0;
 use revolt_presence::{create_session, delete_session};

 use async_std::{
@@ -88,23 +90,51 @@ pub async fn client(db: &'static Database, stream: TcpStream, addr: SocketAddr)
        return;
    };

+    // Presume the token is a proper token first
    let (user, session_id) = match User::from_token(db, token, UserHint::Any).await {
-        Ok(user) => user,
-        Err(err) => {
-            write
-                .send(config.encode(&EventV1::Error { data: err }))
+        Ok((user, session_id)) => {
+            db.update_session_last_seen(&session_id, Timestamp::now_utc())
                .await
                .ok();
-            return;
+
+            (user, session_id)
+        },
+        Err(err) => {
+            let revolt_config = revolt_config::config().await;
+
+            // If it fails to find the user from the token see if its an OAuth2 token
+            let res = match oauth2::decode_token(&revolt_config.api.security.token_secret, token) {
+                // Check if the OAuth2 token is allowed to establish an events websocket
+                Ok(claims) => if !claims.scopes.contains(&v0::OAuth2Scope::Events) {
+                    // TODO: maybe a last_seen system for OAuth2 as well
+                    db.fetch_user(&claims.sub).await.map(|user| (user, claims.jti))
+                } else {
+                    Err(create_error!(MissingScope { scope: v0::OAuth2Scope::Events.to_string() }))
+                },
+                // If its expired return an error
+                Err(e) => if e.into_kind() == oauth2::JWTErrorKind::ExpiredSignature {
+                    Err(create_error!(ExpiredToken))
+                } else {
+                    // Finally re-return the error from User::from_token if everything else fails to avoid a confusing error
+                    Err(err)
+                }
+            };
+
+            match res {
+                Ok(user) => user,
+                Err(err) => {
+                    write
+                        .send(config.encode(&EventV1::Error { data: err }))
+                        .await
+                        .ok();
+                    return;
+                }
+            }
        }
    };

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

-    db.update_session_last_seen(&session_id, Timestamp::now_utc())
-        .await
-        .ok();
-
    // Create local state.
    let mut state = State::from(user, session_id);
    let user_id = state.cache.user_id.clone();
@@ -218,13 +248,7 @@ async fn listener(
    kill_signal_r: async_channel::Receiver<()>,
    write: &Mutex<WsWriter>,
 ) {
-    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 redis_config = RedisConfig::from_url(&REDIS_URI).unwrap();
    let subscriber = match report_internal_error!(
        fred::types::Builder::from_config(redis_config).build_subscriber_client()
    ) {
@@ -428,8 +452,6 @@ 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();
@@ -466,10 +488,6 @@ async fn worker(

                match payload {
                    ClientMessage::BeginTyping { channel } => {
-                        if revolt_config.disable_events_dont_use {
-                            continue;
-                        }
-
                        if !subscribed.read().await.contains(&channel) {
                            continue;
                        }
@@ -482,10 +500,6 @@ async fn worker(
                        .await;
                    }
                    ClientMessage::EndTyping { channel } => {
-                        if revolt_config.disable_events_dont_use {
-                            continue;
-                        }
-
                        if !subscribed.read().await.contains(&channel) {
                            continue;
                        }
@@ -1,11 +1,10 @@
 [package]
 name = "revolt-coalesced"
-version = "0.11.5"
+version = "0.8.9"
 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"]
@@ -16,13 +15,8 @@ default = ["tokio"]

 [dependencies]
 tokio = { version = "1.47.0", features = ["sync"], optional = true }
-indexmap = { version = "2.13.0", optional = true }
-lru = { version = "0.16.3", optional = true }
+indexmap = { version = "*", optional = true }
+lru = { version = "*", optional = true }

 [dev-dependencies]
-tokio = { version = "1.47.0", features = [
-    "rt",
-    "rt-multi-thread",
-    "macros",
-    "time",
-] }
+tokio = { version = "1.47.0", features = ["rt", "rt-multi-thread", "macros", "time"] }
@@ -1,11 +1,10 @@
 [package]
 name = "revolt-config"
-version = "0.11.5"
+version = "0.8.9"
 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

@@ -38,4 +37,4 @@ sentry = { version = "0.31.5", optional = true }
 sentry-anyhow = { version = "0.38.1", optional = true }

 # Core
-revolt-result = { version = "0.11.5", path = "../result", optional = true }
+revolt-result = { version = "0.8.9", path = "../result", optional = true }
@@ -1,5 +1,5 @@
 [database]
-mongodb = "mongodb://localhost?directConnection=true&replicaSet=rs0"
+mongodb = "mongodb://localhost"
 redis = "redis://localhost/"

 [rabbit]
@@ -1,10 +1,9 @@
 production = false
-disable_events_dont_use = false

 [database]
 # MongoDB connection URL
 # Defaults to the container name specified in self-hosted
-mongodb = "mongodb://database?directConnection=true&replicaSet=rs0"
+mongodb = "mongodb://database"
 # Redis connection URL
 # Defaults to the container name specified in self-hosted
 redis = "redis://redis/"
@@ -12,7 +11,7 @@ redis = "redis://redis/"
 [hosts]
 # Web locations of various services
 # Defaults assume all services are reverse-proxied
-# See https://github.com/stoatchat/self-hosted/blob/main/Caddyfile
+# See https://github.com/revoltchat/self-hosted/blob/master/Caddyfile
 #
 # Remember to change these to https/wss where appropriate in production!
 app = "http://local.revolt.chat"
@@ -23,8 +22,6 @@ january = "http://local.revolt.chat/january"
 voso_legacy = ""
 voso_legacy_ws = ""

-[hosts.livekit]
-
 [rabbit]
 host = "rabbit"
 port = 5672
@@ -35,7 +32,7 @@ password = "rabbitpass"

 [api.registration]
 # Whether an invite should be required for registration
-# See https://github.com/stoatchat/self-hosted#making-your-instance-invite-only
+# See https://github.com/revoltchat/self-hosted#making-your-instance-invite-only
 invite_only = false

 [api.smtp]
@@ -59,6 +56,8 @@ voso_legacy_token = ""
 trust_cloudflare = false
 # easypwned endpoint
 easypwned = ""
+# Secret used to encode and decode tokens
+token_secret = ""
 # Tenor API Key
 tenor_key = ""

@@ -71,14 +70,9 @@ hcaptcha_sitekey = ""
 # Maximum concurrent connections (to proxy server)
 max_concurrent_connections = 50

-[api.livekit]
-# How long to ring devices for when calling in dms/groups, in seconds
-call_ring_duration = 30
-
-[api.livekit.nodes]
-
 [api.users]

+
 [pushd]
 # this changes the names of the queues to not overlap 
 # prod/beta if they happen to be on the same exchange/instance.
@@ -89,18 +83,12 @@ 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

@@ -226,10 +214,6 @@ 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

@@ -248,18 +232,6 @@ 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
@@ -287,18 +259,6 @@ 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
@@ -317,9 +277,8 @@ process_message_delay_limit = 5
 # Configuration for Sentry error reporting
 api = ""
 events = ""
-voice_ingress = ""
 files = ""
 proxy = ""
 pushd = ""
 crond = ""
-gifbox = ""
+gifbox = ""
@@ -1,7 +1,7 @@
-use std::{collections::HashMap, path::Path};
+use std::collections::HashMap;

 use cached::proc_macro::cached;
-use config::{Config, Environment, File, FileFormat};
+use config::{Config, File, FileFormat};
 use futures_locks::RwLock;
 use once_cell::sync::Lazy;
 use serde::Deserialize;
@@ -94,23 +94,12 @@ static CONFIG_BUILDER: Lazy<RwLock<Config>> = Lazy::new(|| {
            }
        }

-        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));
-                }
+        for path in CONFIG_SEARCH_PATHS {
+            if std::path::Path::new(path).exists() {
+                builder = builder.add_source(File::new(path, FileFormat::Toml));
            }
-
-            cwd = path.parent();
        }

-        builder = builder.add_source(Environment::with_prefix("REVOLT").separator("__"));
-
        builder.build().unwrap()
    })
 });
@@ -119,7 +108,6 @@ 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)]
@@ -137,7 +125,8 @@ pub struct Hosts {
    pub events: String,
    pub autumn: String,
    pub january: String,
-    pub livekit: HashMap<String, String>,
+    pub voso_legacy: String,
+    pub voso_legacy_ws: String,
 }

 #[derive(Deserialize, Debug, Clone)]
@@ -201,6 +190,7 @@ pub struct ApiSecurity {
    pub captcha: ApiSecurityCaptcha,
    pub trust_cloudflare: bool,
    pub easypwned: String,
+    pub token_secret: String,
    pub tenor_key: String,
 }

@@ -209,25 +199,6 @@ 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>,
@@ -239,7 +210,6 @@ pub struct Api {
    pub smtp: ApiSmtp,
    pub security: ApiSecurity,
    pub workers: ApiWorkers,
-    pub livekit: ApiLiveKit,
    pub users: ApiUsers,
 }

@@ -248,12 +218,10 @@ 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,
@@ -284,10 +252,6 @@ 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())
    }
@@ -345,8 +309,6 @@ pub struct GlobalLimits {
    pub new_user_hours: usize,

    pub body_limit_size: usize,
-
-    pub restrict_server_creation: Vec<String>,
 }

 #[derive(Deserialize, Debug, Clone)]
@@ -357,10 +319,6 @@ 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>,
 }
@@ -405,7 +363,6 @@ 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,
@@ -424,7 +381,6 @@ pub struct Settings {
    pub features: Features,
    pub sentry: Sentry,
    pub production: bool,
-    pub disable_events_dont_use: bool,
 }

 impl Settings {
@@ -455,14 +411,12 @@ pub async fn config() -> Settings {
    let mut config = read().await.try_deserialize::<Settings>().unwrap();

    // inject REDIS_URI for redis-kiss library
-    if std::env::var("REDIS_URI").is_err() {
+    if std::env::var("REDIS_URL").is_err() {
        std::env::set_var("REDIS_URI", config.database.redis.clone());
    }

    // auto-detect production nodes
-    if config.hosts.api.contains("https")
-        && (config.hosts.api.contains("revolt.chat") || config.hosts.api.contains("stoat.chat"))
-    {
+    if config.hosts.api.contains("https") && config.hosts.api.contains("revolt.chat") {
        config.production = true;
    }

@@ -1,11 +1,10 @@
 [package]
 name = "revolt-database"
-version = "0.11.5"
+version = "0.8.9"
 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

@@ -16,35 +15,28 @@ mongodb = ["dep:mongodb", "bson", "authifier/database-mongodb"]
 # ... 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", "revolt-result/axum"]
+rocket-impl = ["rocket", "schemars", "revolt_okapi", "revolt_rocket_okapi", "authifier/rocket_impl"]
+axum-impl = ["axum"]
 redis-is-patched = ["revolt-presence/redis-is-patched"]
-voice = ["livekit-api", "livekit-protocol", "livekit-runtime"]

 # Default Features
 default = ["mongodb", "async-std-runtime", "tasks"]

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

 # Utility
 log = "0.4"
@@ -61,6 +53,8 @@ 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"] }
+jsonwebtoken = "9.3.1"
+chrono = "0.4"

 # Serialisation
 serde_json = "1"
@@ -100,12 +94,7 @@ revolt_okapi = { version = "0.9.1", optional = true }
 revolt_rocket_okapi = { version = "0.10.0", optional = true }

 # Authifier
-authifier = { version = "1.0.16" }
+authifier = { version = "1.0.15" }

 # RabbitMQ
 amqprs = { version = "1.7.0" }
-
-# Voice
-livekit-api = { version = "0.4.4", optional = true }
-livekit-protocol = { version = "0.4.0", optional = true }
-livekit-runtime = { version = "0.3.1", features = ["tokio"], optional = true }
@@ -47,7 +47,6 @@
    ],
    "roles": {
      "__ID:5__": {
-        "_id": "__ID:5__",
        "name": "Moderator",
        "permissions": {
          "a": 545270208,
@@ -56,7 +55,6 @@
        "rank": 1
      },
      "__ID:6__": {
-        "_id": "__ID:6__",
        "name": "Owner",
        "permissions": {
          "a": 0,
@@ -2,8 +2,7 @@ use std::collections::HashSet;

 use crate::events::rabbit::*;
 use crate::User;
-use amqprs::channel::{BasicPublishArguments, ExchangeDeclareArguments};
-use amqprs::connection::OpenConnectionArguments;
+use amqprs::channel::BasicPublishArguments;
 use amqprs::{channel::Channel, connection::Connection, error::Error as AMQPError};
 use amqprs::{BasicProperties, FieldTable};
 use revolt_models::v0::PushNotification;
@@ -26,35 +25,6 @@ impl AMQP {
        }
    }

-    pub async fn new_auto() -> AMQP {
-        let config = revolt_config::config().await;
-
-        let connection = Connection::open(&OpenConnectionArguments::new(
-            &config.rabbit.host,
-            config.rabbit.port,
-            &config.rabbit.username,
-            &config.rabbit.password,
-        ))
-        .await
-        .expect("Failed to connect to RabbitMQ");
-
-        let channel = connection
-            .open_channel(None)
-            .await
-            .expect("Failed to open RabbitMQ channel");
-
-        channel
-            .exchange_declare(
-                ExchangeDeclareArguments::new(&config.pushd.exchange, "direct")
-                    .durable(true)
-                    .finish(),
-            )
-            .await
-            .expect("Failed to declare exchange");
-
-        AMQP::new(connection, channel)
-    }
-
    pub async fn friend_request_accepted(
        &self,
        accepted_request_user: &User,
@@ -270,50 +240,4 @@ impl AMQP {
            )
            .await
    }
-
-    /// # 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.channel
-            .basic_publish(
-                BasicProperties::default()
-                    .with_content_type("application/json")
-                    .with_persistence(true)
-                    .finish(),
-                payload.into(),
-                BasicPublishArguments::new(
-                    &config.pushd.exchange,
-                    &config.pushd.get_dm_call_routing_key(),
-                ),
-            )
-            .await
-    }
 }
@@ -10,7 +10,6 @@ use authifier::config::SMTPSettings;
 use authifier::config::Shield;
 use authifier::config::Template;
 use authifier::config::Templates;
-use authifier::config::EmailExpiryConfig;
 use authifier::Authifier;
 use rand::Rng;
 use revolt_config::config;
@@ -36,7 +35,7 @@ pub enum DatabaseInfo {
 }

 /// Database
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub enum Database {
    /// Mock database
    Reference(ReferenceDb),
@@ -70,7 +69,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
                }
@@ -91,7 +90,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"),
                }
@@ -138,33 +137,29 @@ impl Database {
                                .api
                                .smtp
                                .reply_to
-                                .unwrap_or("support@stoat.chat".into()),
+                                .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: EmailExpiryConfig {
-                        expire_verification: 3600 * 24 * 7,
-                        expire_password_reset: 3600 * 24,
-                        expire_account_deletion: 3600 * 24,
-                    },
+                    expiry: Default::default(),
                    templates: if config.production {
                        Templates {
                            verify: Template {
-                                title: "Verify your Stoat account.".into(),
+                                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 Stoat password.".into(),
+                                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 Stoat account, reset your password."
+                                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),
@@ -11,7 +11,6 @@ use serde::Serialize;

 database_derived!(
    /// MongoDB implementation
-    #[derive(Debug)]
    pub struct MongoDb(pub ::mongodb::Client, pub String);
 );

@@ -5,13 +5,14 @@ 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,
+    User, UserSettings, Webhook, AuthorizedBotId, AuthorizedBot,
 };

 database_derived!(
    /// Reference implementation
-    #[derive(Default, Debug)]
+    #[derive(Default)]
    pub struct ReferenceDb {
+        pub authorized_bots: Arc<Mutex<HashMap<AuthorizedBotId, AuthorizedBot>>>,
        pub bots: Arc<Mutex<HashMap<String, Bot>>>,
        pub channels: Arc<Mutex<HashMap<String, Channel>>>,
        pub channel_invites: Arc<Mutex<HashMap<String, Invite>>>,
@@ -3,7 +3,10 @@ use revolt_result::Error;
 use serde::{Deserialize, Serialize};

 use revolt_models::v0::{
-    AppendMessage, Channel, ChannelUnread, ChannelVoiceState, Emoji, FieldsChannel, FieldsMember, FieldsMessage, FieldsRole, FieldsServer, FieldsUser, FieldsWebhook, Member, MemberCompositeKey, Message, PartialChannel, PartialMember, PartialMessage, PartialRole, PartialServer, PartialUser, PartialUserVoiceState, PartialWebhook, PolicyChange, RemovalIntention, Report, Server, User, UserSettings, UserVoiceState, Webhook
+    AppendMessage, Channel, ChannelUnread, Emoji, FieldsChannel, FieldsMember, FieldsMessage,
+    FieldsRole, FieldsServer, FieldsUser, FieldsWebhook, Member, MemberCompositeKey, Message,
+    PartialChannel, PartialMember, PartialMessage, PartialRole, PartialServer, PartialUser,
+    PartialWebhook, PolicyChange, RemovalIntention, Report, Server, User, UserSettings, Webhook,
 };

 use crate::Database;
@@ -24,7 +27,6 @@ pub struct ReadyPayloadFields {
    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,
@@ -38,7 +40,6 @@ impl Default for ReadyPayloadFields {
            channels: true,
            members: true,
            emojis: true,
-            voice_states: true,
            user_settings: Vec::new(),
            channel_unreads: false,
            policy_changes: true,
@@ -71,8 +72,6 @@ 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>,
@@ -139,7 +138,6 @@ pub enum EventV1 {
        server: Server,
        channels: Vec<Channel>,
        emojis: Vec<Emoji>,
-        voice_states: Vec<ChannelVoiceState>
    },

    /// Update existing server
@@ -272,33 +270,6 @@ pub enum EventV1 {

    /// Auth events
    Auth(AuthifierEvent),
-
-    /// 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,
-    }
 }

 impl EventV1 {
@@ -37,20 +37,6 @@ 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)]
@@ -60,7 +46,6 @@ pub enum PayloadKind {
    FRReceived(FRReceivedPayload),
    BadgeUpdate(usize),
    Generic(GenericPayload),
-    DmCallStartEnd(DmCallPayload),
 }

 #[derive(Serialize, Deserialize)]
@@ -112,10 +112,6 @@ 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
@@ -9,13 +9,14 @@ use crate::{
        bson::{doc, from_bson, from_document, to_document, Bson, DateTime, Document},
        options::FindOptions,
    },
-    AbstractServers, Invite, MongoDb, User, DISCRIMINATOR_SEARCH_SPACE,
+    AbstractChannels, AbstractServers, Channel, 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::{ChannelPermission, DEFAULT_WEBHOOK_PERMISSIONS};
+use revolt_permissions::DEFAULT_WEBHOOK_PERMISSIONS;
+use revolt_result::{Error, ErrorType};
 use serde::{Deserialize, Serialize};
 use unicode_segmentation::UnicodeSegmentation;

@@ -25,7 +26,7 @@ struct MigrationInfo {
    revision: i32,
 }

-pub const LATEST_REVISION: i32 = 50; // MUST BE +1 to last migration
+pub const LATEST_REVISION: i32 = 42; // MUST BE +1 to last migration

 pub async fn migrate_database(db: &MongoDb) {
    let migrations = db.col::<Document>("migrations");
@@ -913,7 +914,6 @@ 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,14 +1080,6 @@ 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")
@@ -1099,8 +1091,8 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
            .await;

        for webhook in webhooks {
-            match db.col::<Channel>("channels").find_one(doc! { "_id": &webhook.channel_id }).await.unwrap() {
-                Some(channel) => {
+            match db.fetch_channel(&webhook.channel_id).await {
+                Ok(channel) => {
                    let creator_id = match channel {
                        Channel::Group { owner, .. } => owner,
                        Channel::TextChannel { server, .. }
@@ -1108,6 +1100,7 @@ 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()
@@ -1125,13 +1118,17 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
                        .await
                        .expect("update webhook");
                }
-                None => {
+                Err(Error {
+                    error_type: ErrorType::NotFound,
+                    ..
+                }) => {
                    db.db()
                        .collection::<WebhookShell>("channel_webhooks")
                        .delete_one(doc! { "_id": webhook._id })
                        .await
                        .expect("failed to delete invalid webhook");
                }
+                Err(err) => panic!("{err:?}"),
            }
        }
    }
@@ -1172,9 +1169,9 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
            .expect("failed to update users");
    }

-    if revision <= 43 {
+    if revision <= 41 {
        info!(
-            "Running migration [revision 43 / 05-06-2025]: convert role ranks to uniform numbers."
+            "Running migration [revision 41 / 05-06-2025]: convert role ranks to uniform numbers."
        );

        #[derive(Serialize, Deserialize, Clone)]
@@ -1229,83 +1226,6 @@ 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();
-        }
-    };
-
    // Reminder to update LATEST_REVISION when adding new migrations.
    LATEST_REVISION.max(revision)
 }
@@ -0,0 +1,5 @@
+mod model;
+mod ops;
+
+pub use model::*;
+pub use ops::*;
@@ -0,0 +1,30 @@
+use iso8601_timestamp::Timestamp;
+
+use crate::OAuth2Scope;
+
+auto_derived! (
+    /// Unique id of the user and bot
+    #[derive(Hash)]
+    pub struct AuthorizedBotId {
+        /// User id
+        pub user: String,
+
+        /// Bot Id
+        pub bot: String,
+    }
+
+    pub struct AuthorizedBot {
+        /// Unique Id
+        #[serde(rename = "_id")]
+        pub id: AuthorizedBotId,
+
+        /// When the authorized oauth2 bot connection was created at
+        pub created_at: Timestamp,
+
+        /// If and when the authorized oauth2 bot connection was revoked at
+        pub deauthorized_at: Option<Timestamp>,
+
+        /// Scopes the bot has access to
+        pub scope: Vec<OAuth2Scope>,
+    }
+);
@@ -0,0 +1,27 @@
+use revolt_result::Result;
+
+use crate::{AuthorizedBot, AuthorizedBotId};
+
+mod mongodb;
+mod reference;
+
+#[async_trait]
+pub trait AbstractAuthorizedBots: Sync + Send {
+    /// Insert emoji into database.
+    async fn insert_authorized_bot(&self, authorized_bot: &AuthorizedBot) -> Result<()>;
+
+    /// Fetch an authorized bot by its id
+    async fn fetch_authorized_bot(&self, id: &AuthorizedBotId) -> Result<AuthorizedBot>;
+
+    /// Fetch a users authorized bot by its id
+    async fn fetch_users_authorized_bots(&self, user_id: &str) -> Result<Vec<AuthorizedBot>>;
+
+    /// Deletes an authorized bot
+    async fn delete_authorized_bot(&self, id: &AuthorizedBotId) -> Result<()>;
+
+    /// Deauthorizes an authorized bot
+    async fn deauthorize_authorized_bot(&self, id: &AuthorizedBotId) -> Result<AuthorizedBot>;
+
+    // Fetches all authorized bots which have been deauthorized
+    async fn fetch_deauthorized_authorized_bots(&self) -> Result<Vec<AuthorizedBot>>;
+}
@@ -0,0 +1,71 @@
+use bson::to_bson;
+use revolt_result::Result;
+use iso8601_timestamp::Timestamp;
+
+use crate::{MongoDb, AuthorizedBot, AuthorizedBotId};
+
+use super::AbstractAuthorizedBots;
+
+static COL: &str = "authorized_bots";
+
+#[async_trait]
+impl AbstractAuthorizedBots for MongoDb {
+    /// Insert an authorized bot into database.
+    async fn insert_authorized_bot(&self, authorized_bot: &AuthorizedBot) -> Result<()> {
+        query!(self, insert_one, COL, &authorized_bot).map(|_| ())
+    }
+
+    /// Fetch an authorized bot by its id
+    async fn fetch_authorized_bot(&self, id: &AuthorizedBotId) -> Result<AuthorizedBot> {
+        query!(
+            self,
+            find_one,
+            COL,
+            doc! {
+                "_id.user": &id.user,
+                "_id.bot": &id.bot
+            }
+        )?.ok_or_else(|| create_error!(NotFound))
+    }
+
+    /// Fetch a users authorized bot by its id
+    async fn fetch_users_authorized_bots(&self, user_id: &str) -> Result<Vec<AuthorizedBot>> {
+        query!(self, find, COL, doc! { "_id.user": &user_id })
+    }
+
+    /// Deletes an authorized bot
+    async fn delete_authorized_bot(&self, id: &AuthorizedBotId) -> Result<()> {
+        query!(self, delete_one, COL, doc! { "_id.user": &id.user, "_id.bot": &id.bot }).map(|_| ())
+    }
+
+    /// Deauthorizes an authorized bot
+    async fn deauthorize_authorized_bot(&self, id: &AuthorizedBotId) -> Result<AuthorizedBot> {
+        self.col::<AuthorizedBot>(COL)
+            .find_one_and_update(
+                doc! {
+                    "_id.user": &id.user,
+                    "_id.bot": &id.bot
+                },
+                doc! {
+                    "$set": {
+                        "deauthorized_at": to_bson(&Timestamp::now_utc()).unwrap()
+                    }
+                }
+            )
+            .await
+            .map_err(|_| create_database_error!("find_one_and_update", COL))
+            .and_then(|opt| opt.ok_or_else(|| create_database_error!("find_one_and_update", COL)))
+    }
+
+    // Fetches all authorized bots which have been deauthorized
+    async fn fetch_deauthorized_authorized_bots(&self) -> Result<Vec<AuthorizedBot>> {
+        query!(
+            self,
+            find,
+            COL,
+            doc! {
+                "deauthorized_at": { "$exists": true }
+            }
+        )
+    }
+}
@@ -0,0 +1,76 @@
+use revolt_result::Result;
+use iso8601_timestamp::Timestamp;
+
+use crate::{ReferenceDb, AuthorizedBot, AuthorizedBotId};
+
+use super::AbstractAuthorizedBots;
+
+#[async_trait]
+impl AbstractAuthorizedBots for ReferenceDb {
+    /// Insert an authorized bot into database.
+    async fn insert_authorized_bot(&self, authorized_bot: &AuthorizedBot) -> Result<()> {
+        let mut authorized_bots = self.authorized_bots.lock().await;
+
+        if authorized_bots.contains_key(&authorized_bot.id) {
+            Err(create_database_error!("insert", "authorized_bots"))
+        } else {
+            authorized_bots.insert(authorized_bot.id.clone(), authorized_bot.clone());
+            Ok(())
+        }
+    }
+
+    /// Fetch an authorized bot by its id
+    async fn fetch_authorized_bot(&self, id: &AuthorizedBotId) -> Result<AuthorizedBot> {
+        let authorized_bots = self.authorized_bots.lock().await;
+
+        authorized_bots.get(id).cloned().ok_or_else(|| create_error!(NotFound))
+    }
+
+    /// Fetch a users authorized bot by its id
+    async fn fetch_users_authorized_bots(&self, user_id: &str) -> Result<Vec<AuthorizedBot>> {
+        let authorized_bots = self.authorized_bots.lock().await;
+
+        Ok(authorized_bots
+            .values()
+            .filter(|authorized_bot| authorized_bot.id.user == user_id)
+            .cloned()
+            .collect()
+        )
+    }
+
+    /// Deletes an authorized bot
+    async fn delete_authorized_bot(&self, id: &AuthorizedBotId) -> Result<()> {
+        let mut authorized_bots = self.authorized_bots.lock().await;
+
+        if authorized_bots.remove(id).is_some() {
+            Ok(())
+        } else {
+            Err(create_error!(NotFound))
+        }
+    }
+
+    /// Deauthorizes an authorized bot
+    async fn deauthorize_authorized_bot(&self, id: &AuthorizedBotId) -> Result<AuthorizedBot> {
+        let mut authorized_bots = self.authorized_bots.lock().await;
+
+        if let Some(authorized_bot) = authorized_bots.get_mut(id) {
+            authorized_bot.deauthorized_at = Some(Timestamp::now_utc());
+
+            Ok(authorized_bot.clone())
+        } else {
+            Err(create_error!(NotFound))
+        }
+    }
+
+    // Fetches all authorized bots which have been deauthorized
+    async fn fetch_deauthorized_authorized_bots(&self) -> Result<Vec<AuthorizedBot>> {
+        let authorized_bots = self.authorized_bots.lock().await;
+
+        Ok(authorized_bots
+            .values()
+            .filter(|authorized_bot| authorized_bot.deauthorized_at.is_some())
+            .cloned()
+            .collect()
+        )
+    }
+}
@@ -1,5 +1,6 @@
 use revolt_result::Result;
 use ulid::Ulid;
+use std::collections::HashMap;

 use crate::{events::client::EventV1, BotInformation, Database, PartialUser, User};

@@ -35,6 +36,10 @@ auto_derived_partial!(
        #[serde(skip_serializing_if = "String::is_empty", default)]
        pub privacy_policy_url: String,

+        /// Oauth2 bot settings
+        #[serde(skip_serializing_if = "Option::is_none", default)]
+        pub oauth2: Option<BotOauth2>,
+
        /// Enum of bot flags
        #[serde(skip_serializing_if = "Option::is_none")]
        pub flags: Option<i32>,
@@ -42,11 +47,52 @@ auto_derived_partial!(
    "PartialBot"
 );

+auto_derived!(
+    #[derive(Copy, Hash)]
+    pub enum OAuth2Scope {
+        #[serde(rename = "read:identify")]
+        ReadIdentify,
+        #[serde(rename = "read:servers")]
+        ReadServers,
+        #[serde(rename = "write:files")]
+        WriteFiles,
+        #[serde(rename = "events")]
+        Events,
+        #[serde(rename = "full")]
+        Full,
+    }
+
+    pub struct OAuth2ScopeReasoning {
+        pub allow: String,
+        pub deny: String
+    }
+);
+
+auto_derived_partial!(
+    pub struct BotOauth2 {
+        /// Whether the oauth2 client is public and should not receive a secret key
+        #[serde(default)]
+        pub public: bool,
+        /// Secret key used for authorisation, not provided if the client is public
+        #[serde(default)]
+        pub secret: Option<String>,
+        /// Allowed redirects for the authorisation
+        #[serde(default)]
+        pub redirects: Vec<String>,
+        /// Mapping of allowed scopes and the reasonings
+        #[serde(default)]
+        pub allowed_scopes: HashMap<OAuth2Scope, OAuth2ScopeReasoning>,
+    },
+    "PartialBotOauth2"
+);
+
 auto_derived!(
    /// Optional fields on bot object
    pub enum FieldsBot {
        Token,
        InteractionsURL,
+        Oauth2,
+        Oauth2Secret,
    }
 );

@@ -63,11 +109,24 @@ impl Default for Bot {
            interactions_url: Default::default(),
            terms_of_service_url: Default::default(),
            privacy_policy_url: Default::default(),
+            oauth2: Default::default(),
            flags: Default::default(),
        }
    }
 }

+#[allow(clippy::derivable_impls)]
+impl Default for BotOauth2 {
+    fn default() -> Self {
+        Self {
+            public: false,
+            secret: Some(nanoid::nanoid!(64)),
+            redirects: Vec::new(),
+            allowed_scopes: HashMap::new(),
+        }
+    }
+}
+
 #[allow(clippy::disallowed_methods)]
 impl Bot {
    /// Create a new bot
@@ -124,6 +183,14 @@ impl Bot {
            FieldsBot::Token => self.token = nanoid::nanoid!(64),
            FieldsBot::InteractionsURL => {
                self.interactions_url = String::new();
+            },
+            FieldsBot::Oauth2 => self.oauth2 = None,
+            FieldsBot::Oauth2Secret => {
+                if let Some(oauth2) = &mut self.oauth2 {
+                    if !oauth2.public {
+                        oauth2.secret = Some(nanoid::nanoid!(64))
+                    }
+                }
            }
        }
    }
@@ -87,6 +87,8 @@ impl IntoDocumentPath for FieldsBot {
        match self {
            FieldsBot::InteractionsURL => Some("interactions_url"),
            FieldsBot::Token => None,
+            FieldsBot::Oauth2 => Some("oauth2"),
+            FieldsBot::Oauth2Secret => None,
        }
    }
 }
@@ -69,7 +69,7 @@ impl Invite {
                creator: creator.id.clone(),
                channel: id.clone(),
            }),
-            Channel::TextChannel { id, server, .. } => {
+            Channel::TextChannel { id, server, .. } | Channel::VoiceChannel { id, server, .. } => {
                Ok(Invite::Server {
                    code,
                    creator: creator.id.clone(),
@@ -1,5 +1,4 @@
-#![allow(deprecated)]
-use std::{borrow::Cow, collections::HashMap};
+use std::collections::HashMap;

 use revolt_config::config;
 use revolt_models::v0::{self, MessageAuthor};
@@ -9,7 +8,8 @@ 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,22 +106,38 @@ 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,

-    #[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>,
+            /// 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,
+        },
    }
 );

@@ -148,10 +164,6 @@ 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
@@ -159,7 +171,6 @@ auto_derived!(
        Description,
        Icon,
        DefaultPermissions,
-        Voice,
    }
 );

@@ -211,21 +222,16 @@ 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::TextChannel {
+            v0::LegacyServerChannelType::Voice => Channel::VoiceChannel {
                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
            },
        };

@@ -426,28 +432,8 @@ impl Channel {
            Channel::DirectMessage { id, .. }
            | Channel::Group { id, .. }
            | Channel::SavedMessages { 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,
+            | Channel::TextChannel { id, .. }
+            | Channel::VoiceChannel { id, .. } => id,
        }
    }

@@ -464,6 +450,12 @@ impl Channel {
                server,
                role_permissions,
                ..
+            }
+            | Channel::VoiceChannel {
+                id,
+                server,
+                role_permissions,
+                ..
            } => {
                db.set_channel_role_permission(id, role_id, permissions)
                    .await?;
@@ -510,7 +502,7 @@ impl Channel {
            clear: remove.into_iter().map(|v| v.into()).collect(),
        }
        .p(match self {
-            Self::TextChannel { server, .. } => server.clone(),
+            Self::TextChannel { server, .. } | Self::VoiceChannel { server, .. } => server.clone(),
            _ => id,
        })
        .await;
@@ -522,13 +514,17 @@ impl Channel {
    pub fn remove_field(&mut self, field: &FieldsChannel) {
        match field {
            FieldsChannel::Description => match self {
-                Self::Group { description, .. } | Self::TextChannel { description, .. } => {
+                Self::Group { description, .. }
+                | Self::TextChannel { description, .. }
+                | Self::VoiceChannel { description, .. } => {
                    description.take();
                }
                _ => {}
            },
            FieldsChannel::Icon => match self {
-                Self::Group { icon, .. } | Self::TextChannel { icon, .. } => {
+                Self::Group { icon, .. }
+                | Self::TextChannel { icon, .. }
+                | Self::VoiceChannel { icon, .. } => {
                    icon.take();
                }
                _ => {}
@@ -537,17 +533,15 @@ impl Channel {
                Self::TextChannel {
                    default_permissions,
                    ..
+                }
+                | Self::VoiceChannel {
+                    default_permissions,
+                    ..
                } => {
                    default_permissions.take();
                }
                _ => {}
            },
-            FieldsChannel::Voice => match self {
-                Self::TextChannel { voice, .. } => {
-                    voice.take();
-                }
-                _ => {}
-            },
        }
    }

@@ -559,7 +553,6 @@ impl Channel {
    }

    /// Apply partial channel to channel
-    #[allow(deprecated)]
    pub fn apply_options(&mut self, partial: PartialChannel) {
        match self {
            Self::SavedMessages { .. } => {}
@@ -608,7 +601,15 @@ impl Channel {
                nsfw,
                default_permissions,
                role_permissions,
-                voice,
+                ..
+            }
+            | Self::VoiceChannel {
+                name,
+                description,
+                icon,
+                nsfw,
+                default_permissions,
+                role_permissions,
                ..
            } => {
                if let Some(v) = partial.name {
@@ -634,10 +635,6 @@ impl Channel {
                if let Some(v) = partial.default_permissions {
                    default_permissions.replace(v);
                }
-
-                if let Some(v) = partial.voice {
-                    voice.replace(v);
-                }
            }
        }
    }
@@ -780,7 +777,6 @@ impl IntoDocumentPath for FieldsChannel {
            FieldsChannel::Description => "description",
            FieldsChannel::Icon => "icon",
            FieldsChannel::DefaultPermissions => "default_permissions",
-            FieldsChannel::Voice => "voice",
        })
    }
 }
@@ -184,7 +184,7 @@ impl AbstractChannels for MongoDb {
    async fn delete_channel(&self, channel: &Channel) -> Result<()> {
        let id = channel.id().to_string();
        let server_id = match channel {
-            Channel::TextChannel { server, .. } => {
+            Channel::TextChannel { server, .. } | Channel::VoiceChannel { server, .. } => {
                Some(server)
            }
            _ => None,
@@ -94,6 +94,9 @@ impl AbstractChannels for ReferenceDb {
            match &mut channel {
                Channel::TextChannel {
                    role_permissions, ..
+                }
+                | Channel::VoiceChannel {
+                    role_permissions, ..
                } => {
                    if role_permissions.get(role_id).is_some() {
                        role_permissions.remove(role_id);
@@ -45,9 +45,7 @@ auto_derived!(
        Image {
            width: isize,
            height: isize,
-            thumbhash: Option<Vec<u8>>,
-            #[serde(default)]
-            animated: bool,
+            // animated: bool // TODO: https://docs.rs/image/latest/image/trait.AnimationDecoder.html for APNG support
        },
        /// File is a video with specific dimensions
        Video { width: isize, height: isize },
@@ -1,3 +1,5 @@
+use std::{collections::HashSet, hash::RandomState};
+
 use indexmap::{IndexMap, IndexSet};
 use iso8601_timestamp::Timestamp;
 use revolt_config::{config, FeaturesLimits};
@@ -7,8 +9,6 @@ use revolt_models::v0::{
 };
 use revolt_permissions::{calculate_channel_permissions, ChannelPermission, PermissionValue};
 use revolt_result::{ErrorType, Result};
-use std::time::SystemTime;
-use std::{collections::HashSet, hash::RandomState};
 use ulid::Ulid;
 use validator::Validate;

@@ -114,11 +114,6 @@ auto_derived!(
        MessagePinned { id: String, by: String },
        #[serde(rename = "message_unpinned")]
        MessageUnpinned { id: String, by: String },
-        #[serde(rename = "call_started")]
-        CallStarted {
-            by: String,
-            finished_at: Option<Timestamp>,
-        },
    }

    /// Name and / or avatar override information
@@ -331,7 +326,9 @@ impl Message {
        }

        let server_id = match channel {
-            Channel::TextChannel { ref server, .. } => Some(server.clone()),
+            Channel::TextChannel { ref server, .. } | Channel::VoiceChannel { ref server, .. } => {
+                Some(server.clone())
+            }
            _ => None,
        };

@@ -388,7 +385,6 @@ impl Message {
            mut role_mentions,
            mut mentions_everyone,
            mut mentions_online,
-            ..
        } = message_mentions;

        if allow_mass_mentions && server_id.is_some() && !role_mentions.is_empty() {
@@ -490,7 +486,6 @@ impl Message {

        // Validate the mentions go to users in the channel/server
        if !user_mentions.is_empty() {
-            #[allow(deprecated)]
            match channel {
                Channel::DirectMessage { ref recipients, .. }
                | Channel::Group { ref recipients, .. } => {
@@ -498,7 +493,8 @@ impl Message {
                    user_mentions.retain(|m| recipients_hash.contains(m));
                    role_mentions.clear();
                }
-                Channel::TextChannel { ref server, .. } => {
+                Channel::TextChannel { ref server, .. }
+                | Channel::VoiceChannel { ref server, .. } => {
                    let mentions_vec = Vec::from_iter(user_mentions.iter().cloned());

                    let valid_members = db.fetch_members(server.as_str(), &mentions_vec[..]).await;
@@ -688,13 +684,9 @@ impl Message {
        )
        .await?;

-        let is_dm_or_group = matches!(
-            channel,
-            Channel::DirectMessage { .. } | Channel::Group { .. }
-        );

        if !self.has_suppressed_notifications()
-            && (is_dm_or_group || self.mentions.is_some() || self.contains_mass_push_mention())
+            && (self.mentions.is_some() || self.contains_mass_push_mention())
        {
            // send Push notifications
            #[cfg(feature = "tasks")]
@@ -808,7 +800,7 @@ impl Message {
        query: MessageQuery,
        perspective: &User,
        include_users: Option<bool>,
-        server_id: Option<&str>,
+        server_id: Option<String>,
    ) -> Result<BulkMessageResponse> {
        let messages: Vec<v0::Message> = db
            .fetch_messages(query)
@@ -851,7 +843,6 @@ impl Message {
                            v0::SystemMessage::MessageUnpinned { by, .. } => {
                                users.push(by.clone());
                            }
-                            v0::SystemMessage::CallStarted { by, .. } => users.push(by.clone()),
                        }
                    }
                    users
@@ -866,7 +857,7 @@ impl Message {
                users,
                members: if let Some(server_id) = server_id {
                    Some(
-                        db.fetch_members(server_id, &user_ids)
+                        db.fetch_members(&server_id, &user_ids)
                            .await?
                            .into_iter()
                            .map(Into::into)
@@ -1035,31 +1026,6 @@ impl Message {
        Ok(())
    }

-    /// Bulk delete messages by an author since a given time
-    pub async fn bulk_delete_by_author_since(
-        db: &Database,
-        channels: &[String],
-        author: &str,
-        since: SystemTime,
-    ) -> Result<()> {
-        let deleted_groups = db
-            .delete_messages_by_author_since(channels, author, since)
-            .await?;
-
-        for (channel_id, message_ids) in deleted_groups {
-            if !message_ids.is_empty() {
-                EventV1::BulkMessageDelete {
-                    channel: channel_id.clone(),
-                    ids: message_ids,
-                }
-                .p(channel_id)
-                .await;
-            }
-        }
-
-        Ok(())
-    }
-
    /// Remove a reaction from a message
    pub async fn remove_reaction(&self, db: &Database, user: &str, emoji: &str) -> Result<()> {
        // Check if it actually exists
@@ -1,5 +1,3 @@
-use std::collections::HashMap;
-use std::time::SystemTime;
 use revolt_result::Result;

 use crate::{AppendMessage, FieldsMessage, Message, MessageQuery, PartialMessage};
@@ -42,12 +40,4 @@ pub trait AbstractMessages: Sync + Send {

    /// Delete messages from a channel by their ids and corresponding channel id
    async fn delete_messages(&self, channel: &str, ids: &[String]) -> Result<()>;
-
-    /// Delete all messages from a specific author in a server from a certain ULID onwards
-    async fn delete_messages_by_author_since(
-        &self,
-        channels: &[String],
-        author: &str,
-        since: SystemTime
-    ) -> Result<HashMap<String, Vec<String>>>;
 }
@@ -1,12 +1,8 @@
 use bson::{to_bson, Document};
 use futures::try_join;
-use futures::StreamExt;
 use mongodb::options::FindOptions;
 use revolt_models::v0::MessageSort;
 use revolt_result::Result;
-use std::collections::{HashMap, HashSet};
-use std::time::SystemTime;
-use ulid::Ulid;

 use crate::{
    AppendMessage, DocumentId, FieldsMessage, IntoDocumentPath, Message, MessageQuery,
@@ -310,112 +306,6 @@ impl AbstractMessages for MongoDb {
            .map(|_| ())
            .map_err(|_| create_database_error!("delete_many", COL))
    }
-
-    /// Delete all messages from a specific author in a server from a certain ULID onwards
-    async fn delete_messages_by_author_since(
-        &self,
-        channels: &[String],
-        author: &str,
-        since: SystemTime,
-    ) -> Result<HashMap<String, Vec<String>>> {
-        let threshold_ulid = Ulid::from_datetime(since).to_string();
-
-        let filter = doc! {
-            "author": author,
-            "channel": { "$in": channels },
-            "_id": { "$gte": &threshold_ulid }
-        };
-
-        let pipeline = vec![
-            doc! { "$match": filter.clone() },
-            doc! {
-                "$project": {
-                    "channel": 1_i32,
-                    "message_id": "$_id",
-                    "attachment_ids": {
-                        "$map": {
-                            "input": { "$ifNull": ["$attachments", Vec::<bson::Bson>::new()] },
-                            "as": "a",
-                            "in": "$$a._id"
-                        }
-                    }
-                }
-            },
-            doc! {
-                "$group": {
-                    "_id": "$channel",
-                    "message_ids": { "$push": "$message_id" },
-                    "attachment_ids_nested": { "$push": "$attachment_ids" }
-                }
-            },
-            doc! {
-                "$project": {
-                    "message_ids": 1_i32,
-                    "attachment_ids": {
-                        "$reduce": {
-                            "input": "$attachment_ids_nested",
-                            "initialValue": Vec::<bson::Bson>::new(),
-                            "in": { "$setUnion": ["$$value", "$$this"] }
-                        }
-                    }
-                }
-            },
-        ];
-
-        #[derive(serde::Deserialize)]
-        struct AggregatedChannel {
-            #[serde(rename = "_id")]
-            channel: String,
-            message_ids: Vec<String>,
-            #[serde(default)]
-            attachment_ids: Vec<String>,
-        }
-
-        let mut cursor = self
-            .col::<Document>(COL)
-            .aggregate(pipeline)
-            .await
-            .map_err(|_| create_database_error!("aggregate", COL))?
-            .with_type::<AggregatedChannel>();
-
-        let mut deleted_messages: HashMap<String, Vec<String>> = HashMap::new();
-        let mut attachment_ids: HashSet<String> = HashSet::new();
-
-        while let Some(result) = cursor.next().await {
-            if let Ok(item) = result {
-                for id in item.attachment_ids {
-                    attachment_ids.insert(id);
-                }
-                deleted_messages.insert(item.channel, item.message_ids);
-            }
-        }
-
-        // Mark attachments as deleted before deleting messages
-        if !attachment_ids.is_empty() {
-            self.col::<Document>("attachments")
-                .update_many(
-                    doc! {
-                        "_id": {
-                            "$in": attachment_ids.into_iter().collect::<Vec<String>>()
-                        }
-                    },
-                    doc! {
-                        "$set": {
-                            "deleted": true
-                        }
-                    },
-                )
-                .await
-                .map_err(|_| create_database_error!("update_many", "attachments"))?;
-        }
-
-        self.col::<Document>(COL)
-            .delete_many(filter)
-            .await
-            .map_err(|_| create_database_error!("delete_many", COL))?;
-
-        Ok(deleted_messages)
-    }
 }

 impl IntoDocumentPath for FieldsMessage {
@@ -1,9 +1,7 @@
-use std::collections::HashMap;
 use futures::future::try_join_all;
 use indexmap::IndexSet;
 use revolt_result::Result;
-use std::time::SystemTime;
-use ulid::Ulid;
+
 use crate::{AppendMessage, FieldsMessage, Message, MessageQuery, PartialMessage, ReferenceDb};

 use super::AbstractMessages;
@@ -288,63 +286,4 @@ impl AbstractMessages for ReferenceDb {

        Ok(())
    }
-
-    /// Delete all messages from a specific author in a list of channels from a certain ULID onwards
-    async fn delete_messages_by_author_since(
-        &self,
-        channels: &[String],
-        author: &str,
-        since: SystemTime
-    ) -> Result<HashMap<String, Vec<String>>> {
-        let threshold_ulid = Ulid::from_datetime(since).to_string();
-        let mut deleted_messages: HashMap<String, Vec<String>> = HashMap::new();
-        let mut attachment_ids: Vec<String> = Vec::new();
-
-        let messages = self.messages.lock().await;
-
-        // First pass: collect attachment IDs and message IDs to delete
-        for (id, message) in messages.iter() {
-            let should_delete = message.author == author
-                && channels.contains(&message.channel)
-                && id.as_str() >= threshold_ulid.as_str();
-
-            if should_delete {
-                // Collect attachment IDs
-                if let Some(attachments) = &message.attachments {
-                    for attachment in attachments {
-                        attachment_ids.push(attachment.id.clone());
-                    }
-                }
-
-                deleted_messages
-                    .entry(message.channel.clone())
-                    .or_default()
-                    .push(id.clone());
-            }
-        }
-        drop(messages);
-
-        // Mark attachments as deleted
-        if !attachment_ids.is_empty() {
-            let mut files = self.files.lock().await;
-            for attachment_id in attachment_ids {
-                if let Some(file) = files.get_mut(&attachment_id) {
-                    file.deleted = Some(true);
-                }
-            }
-        }
-
-        // Delete the messages
-        self.messages
-            .lock()
-            .await
-            .retain(|id, message| {
-                let should_keep = !(message.author == author
-                    && channels.contains(&message.channel)
-                    && id.as_str() >= threshold_ulid.as_str());
-                should_keep
-            });
-
-        Ok(deleted_messages)
-    }
 }
@@ -1,4 +1,5 @@
 mod admin_migrations;
+mod authorized_bots;
 mod bots;
 mod channel_invites;
 mod channel_unreads;
@@ -19,6 +20,7 @@ mod user_settings;
 mod users;

 pub use admin_migrations::*;
+pub use authorized_bots::*;
 pub use bots::*;
 pub use channel_invites::*;
 pub use channel_unreads::*;
@@ -46,6 +48,7 @@ use crate::MongoDb;
 pub trait AbstractDatabase:
    Sync
    + Send
+    + authorized_bots::AbstractAuthorizedBots
    + admin_migrations::AbstractMigrations
    + bots::AbstractBots
    + channels::AbstractChannels
@@ -7,14 +7,6 @@ use crate::{
    Server, SystemMessage, User,
 };

-fn default_true() -> bool {
-    true
-}
-
-fn is_true(x: &bool) -> bool {
-    *x
-}
-
 auto_derived_partial!(
    /// Server Member
    pub struct Member {
@@ -38,13 +30,6 @@ auto_derived_partial!(
        /// Timestamp this member is timed out until
        #[serde(skip_serializing_if = "Option::is_none")]
        pub timeout: Option<Timestamp>,
-
-        /// Whether the member is server-wide voice muted
-        #[serde(skip_serializing_if = "is_true", default = "default_true")]
-        pub can_publish: bool,
-        /// Whether the member is server-wide voice deafened
-        #[serde(skip_serializing_if = "is_true", default = "default_true")]
-        pub can_receive: bool,
        // This value only exists in the database, not the models.
        // If it is not-None, the database layer should return None to member fetching queries.
        // pub pending_deletion_at: Option<Timestamp>
@@ -68,10 +53,7 @@ auto_derived!(
        Avatar,
        Roles,
        Timeout,
-        CanReceive,
-        CanPublish,
        JoinedAt,
-        VoiceChannel,
    }

    /// Member removal intention
@@ -91,8 +73,6 @@ impl Default for Member {
            avatar: None,
            roles: vec![],
            timeout: None,
-            can_publish: true,
-            can_receive: true,
        }
    }
 }
@@ -147,20 +127,6 @@ impl Member {

        let emojis = db.fetch_emoji_by_parent_id(&server.id).await?;

-        #[allow(unused_mut)]
-        let mut voice_states = Vec::new();
-
-        #[cfg(feature = "voice")]
-        for channel in &channels {
-            if let Ok(Some(voice_state)) = crate::voice::get_channel_voice_state(
-                &crate::voice::UserVoiceChannel::from_channel(channel),
-            )
-            .await
-            {
-                voice_states.push(voice_state)
-            }
-        }
-
        EventV1::ServerMemberJoin {
            id: server.id.clone(),
            user: user.id.clone(),
@@ -178,7 +144,6 @@ impl Member {
                .map(|channel| channel.into())
                .collect(),
            emojis: emojis.into_iter().map(|emoji| emoji.into()).collect(),
-            voice_states,
        }
        .private(user.id.clone())
        .await;
@@ -228,14 +193,11 @@ impl Member {

    pub fn remove_field(&mut self, field: &FieldsMember) {
        match field {
-            FieldsMember::JoinedAt => {}
+            FieldsMember::JoinedAt => (),
            FieldsMember::Avatar => self.avatar = None,
            FieldsMember::Nickname => self.nickname = None,
            FieldsMember::Roles => self.roles.clear(),
            FieldsMember::Timeout => self.timeout = None,
-            FieldsMember::CanReceive => self.can_receive = true,
-            FieldsMember::CanPublish => self.can_publish = true,
-            FieldsMember::VoiceChannel => {}
        }
    }

@@ -330,15 +330,12 @@ impl AbstractServerMembers for MongoDb {

 impl IntoDocumentPath for FieldsMember {
    fn as_path(&self) -> Option<&'static str> {
-        match self {
-            FieldsMember::JoinedAt => Some("joined_at"),
-            FieldsMember::Avatar => Some("avatar"),
-            FieldsMember::Nickname => Some("nickname"),
-            FieldsMember::Roles => Some("roles"),
-            FieldsMember::Timeout => Some("timeout"),
-            FieldsMember::CanPublish => Some("can_publish"),
-            FieldsMember::CanReceive => Some("can_receive"),
-            FieldsMember::VoiceChannel => None,
-        }
+        Some(match self {
+            FieldsMember::JoinedAt => "joined_at",
+            FieldsMember::Avatar => "avatar",
+            FieldsMember::Nickname => "nickname",
+            FieldsMember::Roles => "roles",
+            FieldsMember::Timeout => "timeout",
+        })
    }
 }
@@ -68,9 +68,6 @@ auto_derived_partial!(
 auto_derived_partial!(
    /// Role
    pub struct Role {
-        /// Unique Id
-        #[serde(rename = "_id")]
-        pub id: String,
        /// Role name
        pub name: String,
        /// Permissions available to this role
@@ -249,6 +246,7 @@ impl Server {
            role.update(
                db,
                &self.id,
+                role_id,
                PartialRole {
                    permissions: Some(permissions),
                    ..Default::default()
@@ -299,7 +297,6 @@ impl Role {
    /// Into optional struct
    pub fn into_optional(self) -> PartialRole {
        PartialRole {
-            id: Some(self.id),
            name: Some(self.name),
            permissions: Some(self.permissions),
            colour: self.colour,
@@ -309,29 +306,20 @@ impl Role {
    }

    /// Create a role
-    pub async fn create(db: &Database, server: &Server, name: String) -> Result<Self> {
-        let role = Role {
-            id: Ulid::new().to_string(),
-            name,
-            // Rank of the new role should be below the lowest role
-            rank: server.roles.len() as i64,
-            colour: None,
-            hoist: false,
-            permissions: Default::default(),
-        };
-
-        db.insert_role(&server.id, &role).await?;
+    pub async fn create(&self, db: &Database, server_id: &str) -> Result<String> {
+        let role_id = Ulid::new().to_string();
+        db.insert_role(server_id, &role_id, self).await?;

        EventV1::ServerRoleUpdate {
-            id: server.id.clone(),
-            role_id: role.id.clone(),
-            data: role.clone().into_optional().into(),
+            id: server_id.to_string(),
+            role_id: role_id.to_string(),
+            data: self.clone().into_optional().into(),
            clear: vec![],
        }
-        .p(server.id.clone())
+        .p(server_id.to_string())
        .await;

-        Ok(role)
+        Ok(role_id)
    }

    /// Update server data
@@ -339,6 +327,7 @@ impl Role {
        &mut self,
        db: &Database,
        server_id: &str,
+        role_id: &str,
        partial: PartialRole,
        remove: Vec<FieldsRole>,
    ) -> Result<()> {
@@ -348,14 +337,14 @@ impl Role {

        self.apply_options(partial.clone());

-        db.update_role(server_id, &self.id, &partial, remove.clone())
+        db.update_role(server_id, role_id, &partial, remove.clone())
            .await?;

        EventV1::ServerRoleUpdate {
            id: server_id.to_string(),
-            role_id: self.id.clone(),
+            role_id: role_id.to_string(),
            data: partial.into(),
-            clear: remove.into_iter().map(Into::into).collect(),
+            clear: vec![],
        }
        .p(server_id.to_string())
        .await;
@@ -371,15 +360,15 @@ impl Role {
    }

    /// Delete a role
-    pub async fn delete(self, db: &Database, server_id: &str) -> Result<()> {
+    pub async fn delete(self, db: &Database, server_id: &str, role_id: &str) -> Result<()> {
        EventV1::ServerRoleDelete {
            id: server_id.to_string(),
-            role_id: self.id.clone(),
+            role_id: role_id.to_string(),
        }
        .p(server_id.to_string())
        .await;

-        db.delete_role(server_id, &self.id).await
+        db.delete_role(server_id, role_id).await
    }
 }

@@ -29,7 +29,7 @@ pub trait AbstractServers: Sync + Send {
    async fn delete_server(&self, id: &str) -> Result<()>;

    /// Insert a new role into server object
-    async fn insert_role(&self, server_id: &str, role: &Role) -> Result<()>;
+    async fn insert_role(&self, server_id: &str, role_id: &str, role: &Role) -> Result<()>;

    /// Update an existing role on a server
    async fn update_role(
@@ -69,7 +69,7 @@ impl AbstractServers for MongoDb {
    }

    /// Insert a new role into server object
-    async fn insert_role(&self, server_id: &str, role: &Role) -> Result<()> {
+    async fn insert_role(&self, server_id: &str, role_id: &str, role: &Role) -> Result<()> {
        self.col::<Document>(COL)
            .update_one(
                doc! {
@@ -77,7 +77,7 @@ impl AbstractServers for MongoDb {
                },
                doc! {
                    "$set": {
-                        "roles.".to_owned() + &role.id: to_document(role)
+                        "roles.".to_owned() + role_id: to_document(role)
                            .map_err(|_| create_database_error!("to_document", "role"))?
                    }
                },
@@ -72,10 +72,10 @@ impl AbstractServers for ReferenceDb {
    }

    /// Insert a new role into server object
-    async fn insert_role(&self, server_id: &str, role: &Role) -> Result<()> {
+    async fn insert_role(&self, server_id: &str, role_id: &str, role: &Role) -> Result<()> {
        let mut servers = self.servers.lock().await;
        if let Some(server) = servers.get_mut(server_id) {
-            server.roles.insert(role.id.clone(), role.clone());
+            server.roles.insert(role_id.to_string(), role.clone());
            Ok(())
        } else {
            Err(create_error!(NotFound))
@@ -1,8 +1,10 @@
 use axum::{extract::{FromRef, FromRequestParts}, http::request::Parts};

+use revolt_config::config;
+use revolt_models::v0;
 use revolt_result::{create_error, Error, Result};

-use crate::{Database, User};
+use crate::{util::oauth2, Database, OAuth2Scope, User};

 #[async_trait::async_trait]
 impl<S> FromRequestParts<S> for User
@@ -23,6 +25,24 @@ where
        {
            let session = db.fetch_session_by_token(session_token).await?;
            db.fetch_user(&session.user_id).await
+        } else if let Some(Ok(header_oauth_token)) = parts.headers.get("x-oauth2-token").map(|v| v.to_str()) {
+            let config = config().await;
+
+            let claims = oauth2::decode_token(
+                &config.api.security.token_secret,
+                header_oauth_token,
+            ).map_err(|_| create_error!(NotAuthenticated))?;
+
+            let required_scope: v0::OAuth2Scope = parts.extensions.get::<OAuth2Scope>()
+                .copied()
+                .ok_or_else(|| create_error!(NotAuthenticated))?
+                .into();
+
+            if claims.scopes.contains(&v0::OAuth2Scope::Full) || claims.scopes.contains(&required_scope) {
+                db.fetch_user(&claims.sub).await
+            } else {
+                Err(create_error!(MissingScope { scope: required_scope.to_string() }))
+            }
        } else {
            Err(create_error!(NotAuthenticated))
        }
@@ -1,7 +1,10 @@
 use authifier::models::Session;
+use revolt_config::config;
+use revolt_models::v0;
 use rocket::http::Status;
 use rocket::request::{self, FromRequest, Outcome, Request};

+use crate::util::oauth2;
 use crate::{Database, User};

 #[rocket::async_trait]
@@ -19,12 +22,38 @@ impl<'r> FromRequest<'r> for User {
                    .next()
                    .map(|x| x.to_string());

+                let header_oauth_token = request
+                    .headers()
+                    .get("x-oauth2-token")
+                    .next()
+                    .map(|x| x.to_string());
+
                if let Some(bot_token) = header_bot_token {
                    if let Ok(bot) = db.fetch_bot_by_token(&bot_token).await {
                        if let Ok(user) = db.fetch_user(&bot.id).await {
                            return Some(user);
                        }
                    }
+                } else if let Some(header_oauth_token) = header_oauth_token {
+                    let config = config().await;
+
+                    let claims = oauth2::decode_token(
+                        &config.api.security.token_secret,
+                        &header_oauth_token,
+                    )
+                    .ok()?;
+
+                    // access the scope required for the route stored in the request local cache set via `OAuth2Scoped`
+                    let required_scope: v0::OAuth2Scope = request.local_cache(|| None::<crate::OAuth2Scope>)
+                        .as_ref()
+                        .copied()?
+                        .into();
+
+                    if claims.scopes.contains(&v0::OAuth2Scope::Full) || claims.scopes.contains(&required_scope) {
+                        if let Ok(user) = db.fetch_user(&claims.sub).await {
+                            return Some(user);
+                        }
+                    }
                } else if let Outcome::Success(session) = request.guard::<Session>().await {
                    if let Ok(user) = db.fetch_user(&session.user_id).await {
                        return Some(user);
@@ -14,7 +14,7 @@ use validator::HasLen;
 use revolt_result::Result;

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

 /// Enumeration of possible events
 #[derive(Debug, Eq, PartialEq)]
@@ -191,14 +191,17 @@ pub async fn handle_ack_event(
                    .await
                    .expect("Failed to fetch channel from db");

-                if let TextChannel { server, .. } = channel {
-                    if let Err(err) =
-                        amqp.mass_mention_message_sent(server, mass_mentions).await
-                    {
-                        revolt_config::capture_error(&err);
+                match channel {
+                    TextChannel { server, .. } | VoiceChannel { server, .. } => {
+                        if let Err(err) =
+                            amqp.mass_mention_message_sent(server, mass_mentions).await
+                        {
+                            revolt_config::capture_error(&err);
+                        }
+                    }
+                    _ => {
+                        panic!("Unknown channel type when sending mass mention event");
                    }
-                } else {
-                    panic!("Unknown channel type when sending mass mention event");
                }
            }
        }
@@ -33,6 +33,7 @@ impl From<crate::Bot> for Bot {
            interactions_url: value.interactions_url,
            terms_of_service_url: value.terms_of_service_url,
            privacy_policy_url: value.privacy_policy_url,
+            oauth2: value.oauth2.map(|oauth2| oauth2.into()),
            flags: value.flags.unwrap_or_default() as u32,
        }
    }
@@ -43,6 +44,8 @@ impl From<FieldsBot> for crate::FieldsBot {
        match value {
            FieldsBot::InteractionsURL => crate::FieldsBot::InteractionsURL,
            FieldsBot::Token => crate::FieldsBot::Token,
+            FieldsBot::Oauth2 => crate::FieldsBot::Oauth2,
+            FieldsBot::Oauth2Secret => crate::FieldsBot::Oauth2Secret,
        }
    }
 }
@@ -52,6 +55,78 @@ impl From<crate::FieldsBot> for FieldsBot {
        match value {
            crate::FieldsBot::InteractionsURL => FieldsBot::InteractionsURL,
            crate::FieldsBot::Token => FieldsBot::Token,
+            crate::FieldsBot::Oauth2 => FieldsBot::Oauth2,
+            crate::FieldsBot::Oauth2Secret => FieldsBot::Oauth2Secret,
+        }
+    }
+}
+
+impl From<BotOauth2> for crate::BotOauth2 {
+    fn from(value: BotOauth2) -> Self {
+        crate::BotOauth2 {
+            public: value.public,
+            secret: value.secret,
+            redirects: value.redirects,
+            allowed_scopes: value.allowed_scopes
+                .into_iter()
+                .map(|(scope, value)| (scope.into(), value.into()))
+                .collect(),
+        }
+    }
+}
+
+impl From<crate::BotOauth2> for BotOauth2 {
+    fn from(value: crate::BotOauth2) -> Self {
+        BotOauth2 {
+            public: value.public,
+            secret: value.secret,
+            redirects: value.redirects,
+            allowed_scopes: value.allowed_scopes
+                .into_iter()
+                .map(|(scope, value)| (scope.into(), value.into()))
+                .collect(),
+        }
+    }
+}
+
+impl From<crate::OAuth2Scope> for OAuth2Scope {
+    fn from(value: crate::OAuth2Scope) -> Self {
+        match value {
+            crate::OAuth2Scope::ReadIdentify => OAuth2Scope::ReadIdentify,
+            crate::OAuth2Scope::ReadServers => OAuth2Scope::ReadServers,
+            crate::OAuth2Scope::WriteFiles => OAuth2Scope::WriteFiles,
+            crate::OAuth2Scope::Events => OAuth2Scope::Events,
+            crate::OAuth2Scope::Full => OAuth2Scope::Full,
+        }
+    }
+}
+
+impl From<OAuth2Scope> for crate::OAuth2Scope {
+    fn from(value: OAuth2Scope) -> Self {
+        match value {
+            OAuth2Scope::ReadIdentify => crate::OAuth2Scope::ReadIdentify,
+            OAuth2Scope::ReadServers => crate::OAuth2Scope::ReadServers,
+            OAuth2Scope::WriteFiles => crate::OAuth2Scope::WriteFiles,
+            OAuth2Scope::Events => crate::OAuth2Scope::Events,
+            OAuth2Scope::Full => crate::OAuth2Scope::Full,
+        }
+    }
+}
+
+impl From<crate::OAuth2ScopeReasoning> for OAuth2ScopeReasoning {
+    fn from(value: crate::OAuth2ScopeReasoning) -> Self {
+        OAuth2ScopeReasoning {
+            allow: value.allow,
+            deny: value.deny,
+        }
+    }
+}
+
+impl From<OAuth2ScopeReasoning> for crate::OAuth2ScopeReasoning {
+    fn from(value: OAuth2ScopeReasoning) -> Self {
+        crate::OAuth2ScopeReasoning {
+            allow: value.allow,
+            deny: value.deny,
        }
    }
 }
@@ -143,7 +218,6 @@ impl From<crate::FieldsWebhook> for FieldsWebhook {
 }

 impl From<crate::Channel> for Channel {
-    #[allow(deprecated)]
    fn from(value: crate::Channel) -> Self {
        match value {
            crate::Channel::SavedMessages { id, user } => Channel::SavedMessages { id, user },
@@ -189,8 +263,6 @@ impl From<crate::Channel> for Channel {
                default_permissions,
                role_permissions,
                nsfw,
-                voice,
-                slowmode
            } => Channel::TextChannel {
                id,
                server,
@@ -201,15 +273,31 @@ impl From<crate::Channel> for Channel {
                default_permissions,
                role_permissions,
                nsfw,
-                voice: voice.map(|voice| voice.into()),
-                slowmode
+            },
+            crate::Channel::VoiceChannel {
+                id,
+                server,
+                name,
+                description,
+                icon,
+                default_permissions,
+                role_permissions,
+                nsfw,
+            } => Channel::VoiceChannel {
+                id,
+                server,
+                name,
+                description,
+                icon: icon.map(|file| file.into()),
+                default_permissions,
+                role_permissions,
+                nsfw,
            },
        }
    }
 }

 impl From<Channel> for crate::Channel {
-    #[allow(deprecated)]
    fn from(value: Channel) -> crate::Channel {
        match value {
            Channel::SavedMessages { id, user } => crate::Channel::SavedMessages { id, user },
@@ -255,8 +343,6 @@ impl From<Channel> for crate::Channel {
                default_permissions,
                role_permissions,
                nsfw,
-                voice,
-                slowmode
            } => crate::Channel::TextChannel {
                id,
                server,
@@ -267,8 +353,25 @@ impl From<Channel> for crate::Channel {
                default_permissions,
                role_permissions,
                nsfw,
-                voice: voice.map(|voice| voice.into()),
-                slowmode
+            },
+            Channel::VoiceChannel {
+                id,
+                server,
+                name,
+                description,
+                icon,
+                default_permissions,
+                role_permissions,
+                nsfw,
+            } => crate::Channel::VoiceChannel {
+                id,
+                server,
+                name,
+                description,
+                icon: icon.map(|file| file.into()),
+                default_permissions,
+                role_permissions,
+                nsfw,
            },
        }
    }
@@ -287,8 +390,6 @@ impl From<crate::PartialChannel> for PartialChannel {
            role_permissions: value.role_permissions,
            default_permissions: value.default_permissions,
            last_message_id: value.last_message_id,
-            voice: value.voice.map(|voice| voice.into()),
-            slowmode: value.slowmode,
        }
    }
 }
@@ -306,8 +407,6 @@ impl From<PartialChannel> for crate::PartialChannel {
            role_permissions: value.role_permissions,
            default_permissions: value.default_permissions,
            last_message_id: value.last_message_id,
-            voice: value.voice.map(|voice| voice.into()),
-            slowmode: value.slowmode
        }
    }
 }
@@ -318,7 +417,6 @@ impl From<FieldsChannel> for crate::FieldsChannel {
            FieldsChannel::Description => crate::FieldsChannel::Description,
            FieldsChannel::Icon => crate::FieldsChannel::Icon,
            FieldsChannel::DefaultPermissions => crate::FieldsChannel::DefaultPermissions,
-            FieldsChannel::Voice => crate::FieldsChannel::Voice,
        }
    }
 }
@@ -329,7 +427,6 @@ impl From<crate::FieldsChannel> for FieldsChannel {
            crate::FieldsChannel::Description => FieldsChannel::Description,
            crate::FieldsChannel::Icon => FieldsChannel::Icon,
            crate::FieldsChannel::DefaultPermissions => FieldsChannel::DefaultPermissions,
-            crate::FieldsChannel::Voice => FieldsChannel::Voice,
        }
    }
 }
@@ -412,16 +509,9 @@ impl From<crate::Metadata> for Metadata {
        match value {
            crate::Metadata::File => Metadata::File,
            crate::Metadata::Text => Metadata::Text,
-            crate::Metadata::Image {
-                width,
-                height,
-                thumbhash,
-                animated,
-            } => Metadata::Image {
+            crate::Metadata::Image { width, height } => Metadata::Image {
                width: width as usize,
                height: height as usize,
-                thumbhash,
-                animated,
            },
            crate::Metadata::Video { width, height } => Metadata::Video {
                width: width as usize,
@@ -437,16 +527,9 @@ impl From<Metadata> for crate::Metadata {
        match value {
            Metadata::File => crate::Metadata::File,
            Metadata::Text => crate::Metadata::Text,
-            Metadata::Image {
-                width,
-                height,
-                thumbhash,
-                animated,
-            } => crate::Metadata::Image {
+            Metadata::Image { width, height } => crate::Metadata::Image {
                width: width as isize,
                height: height as isize,
-                thumbhash,
-                animated,
            },
            Metadata::Video { width, height } => crate::Metadata::Video {
                width: width as isize,
@@ -535,9 +618,6 @@ impl From<crate::SystemMessage> for SystemMessage {
            crate::SystemMessage::UserRemove { id, by } => Self::UserRemove { id, by },
            crate::SystemMessage::MessagePinned { id, by } => Self::MessagePinned { id, by },
            crate::SystemMessage::MessageUnpinned { id, by } => Self::MessageUnpinned { id, by },
-            crate::SystemMessage::CallStarted { by, finished_at } => {
-                Self::CallStarted { by, finished_at }
-            }
        }
    }
 }
@@ -634,8 +714,6 @@ impl From<crate::Member> for Member {
            avatar: value.avatar.map(|f| f.into()),
            roles: value.roles,
            timeout: value.timeout,
-            can_publish: value.can_publish,
-            can_receive: value.can_receive,
        }
    }
 }
@@ -649,8 +727,6 @@ impl From<Member> for crate::Member {
            avatar: value.avatar.map(|f| f.into()),
            roles: value.roles,
            timeout: value.timeout,
-            can_publish: value.can_publish,
-            can_receive: value.can_receive,
        }
    }
 }
@@ -664,8 +740,6 @@ impl From<crate::PartialMember> for PartialMember {
            avatar: value.avatar.map(|f| f.into()),
            roles: value.roles,
            timeout: value.timeout,
-            can_publish: value.can_publish,
-            can_receive: value.can_receive,
        }
    }
 }
@@ -679,8 +753,6 @@ impl From<PartialMember> for crate::PartialMember {
            avatar: value.avatar.map(|f| f.into()),
            roles: value.roles,
            timeout: value.timeout,
-            can_publish: value.can_publish,
-            can_receive: value.can_receive,
        }
    }
 }
@@ -710,10 +782,7 @@ impl From<crate::FieldsMember> for FieldsMember {
            crate::FieldsMember::Nickname => FieldsMember::Nickname,
            crate::FieldsMember::Roles => FieldsMember::Roles,
            crate::FieldsMember::Timeout => FieldsMember::Timeout,
-            crate::FieldsMember::CanReceive => FieldsMember::CanReceive,
-            crate::FieldsMember::CanPublish => FieldsMember::CanPublish,
            crate::FieldsMember::JoinedAt => FieldsMember::JoinedAt,
-            crate::FieldsMember::VoiceChannel => FieldsMember::VoiceChannel,
        }
    }
 }
@@ -725,10 +794,7 @@ impl From<FieldsMember> for crate::FieldsMember {
            FieldsMember::Nickname => crate::FieldsMember::Nickname,
            FieldsMember::Roles => crate::FieldsMember::Roles,
            FieldsMember::Timeout => crate::FieldsMember::Timeout,
-            FieldsMember::CanReceive => crate::FieldsMember::CanReceive,
-            FieldsMember::CanPublish => crate::FieldsMember::CanPublish,
            FieldsMember::JoinedAt => crate::FieldsMember::JoinedAt,
-            FieldsMember::VoiceChannel => crate::FieldsMember::VoiceChannel,
        }
    }
 }
@@ -920,7 +986,6 @@ impl From<SystemMessageChannels> for crate::SystemMessageChannels {
 impl From<crate::Role> for Role {
    fn from(value: crate::Role) -> Self {
        Role {
-            id: value.id,
            name: value.name,
            permissions: value.permissions,
            colour: value.colour,
@@ -933,7 +998,6 @@ impl From<crate::Role> for Role {
 impl From<Role> for crate::Role {
    fn from(value: Role) -> crate::Role {
        crate::Role {
-            id: value.id,
            name: value.name,
            permissions: value.permissions,
            colour: value.colour,
@@ -946,7 +1010,6 @@ impl From<Role> for crate::Role {
 impl From<crate::PartialRole> for PartialRole {
    fn from(value: crate::PartialRole) -> Self {
        PartialRole {
-            id: value.id,
            name: value.name,
            permissions: value.permissions,
            colour: value.colour,
@@ -959,7 +1022,6 @@ impl From<crate::PartialRole> for PartialRole {
 impl From<PartialRole> for crate::PartialRole {
    fn from(value: PartialRole) -> crate::PartialRole {
        crate::PartialRole {
-            id: value.id,
            name: value.name,
            permissions: value.permissions,
            colour: value.colour,
@@ -1401,18 +1463,42 @@ impl From<FieldsMessage> for crate::FieldsMessage {
    }
 }

-impl From<VoiceInformation> for crate::VoiceInformation {
-    fn from(value: VoiceInformation) -> Self {
-        crate::VoiceInformation {
-            max_users: value.max_users,
+impl From<AuthorizedBotId> for crate::AuthorizedBotId {
+    fn from(value: AuthorizedBotId) -> Self {
+        crate::AuthorizedBotId {
+            user: value.user,
+            bot: value.bot
        }
    }
 }

-impl From<crate::VoiceInformation> for VoiceInformation {
-    fn from(value: crate::VoiceInformation) -> Self {
-        VoiceInformation {
-            max_users: value.max_users,
+impl From<crate::AuthorizedBotId> for AuthorizedBotId {
+    fn from(value: crate::AuthorizedBotId) -> Self {
+        AuthorizedBotId {
+            user: value.user,
+            bot: value.bot
        }
    }
 }
+
+impl From<AuthorizedBot> for crate::AuthorizedBot {
+    fn from(value: AuthorizedBot) -> Self {
+        crate::AuthorizedBot {
+            id: value.id.into(),
+            created_at: value.created_at,
+            deauthorized_at: value.deauthorized_at,
+            scope: value.scope.into_iter().map(|scope| scope.into()).collect(),
+        }
+    }
+}
+
+impl From<crate::AuthorizedBot> for AuthorizedBot {
+    fn from(value: crate::AuthorizedBot) -> Self {
+        AuthorizedBot {
+            id: value.id.into(),
+            created_at: value.created_at,
+            deauthorized_at: value.deauthorized_at,
+            scope: value.scope.into_iter().map(|scope| scope.into()).collect(),
+        }
+    }
+}
@@ -144,6 +144,10 @@ impl<'z> BulkDatabasePermissionQuery<'z> {
                Channel::TextChannel {
                    default_permissions,
                    ..
+                }
+                | Channel::VoiceChannel {
+                    default_permissions,
+                    ..
                } => default_permissions.unwrap_or_default().into(),
                _ => Default::default(),
            }
@@ -152,14 +156,16 @@ impl<'z> BulkDatabasePermissionQuery<'z> {
        }
    }

-    #[allow(dead_code, deprecated)]
+    #[allow(dead_code)]
    fn get_channel_type(&mut self) -> ChannelType {
        if let Some(channel) = &self.channel {
            match channel {
                Channel::DirectMessage { .. } => ChannelType::DirectMessage,
                Channel::Group { .. } => ChannelType::Group,
                Channel::SavedMessages { .. } => ChannelType::SavedMessages,
-                Channel::TextChannel { .. } => ChannelType::ServerChannel,
+                Channel::TextChannel { .. } | Channel::VoiceChannel { .. } => {
+                    ChannelType::ServerChannel
+                }
            }
        } else {
            ChannelType::Unknown
@@ -173,6 +179,9 @@ impl<'z> BulkDatabasePermissionQuery<'z> {
            match channel {
                Channel::TextChannel {
                    role_permissions, ..
+                }
+                | Channel::VoiceChannel {
+                    role_permissions, ..
                } => role_permissions,
                _ => panic!("Not supported for non-server channels"),
            }
@@ -199,6 +208,12 @@ async fn calculate_members_permissions<'a>(
            role_permissions,
            default_permissions,
            ..
+        }
+        | Channel::VoiceChannel {
+            id,
+            role_permissions,
+            default_permissions,
+            ..
        } => (id, role_permissions, default_permissions),
        _ => panic!("Calculation of member permissions must be done on a server channel"),
    };
@@ -1,24 +0,0 @@
-use crate::Database;
-use revolt_result::Result;
-
-/// Formats a user's name depending on their optional features and location.
-/// Factors in server display names and user display names before falling back to username#discriminator.
-/// Passing a server in which the user is not a member will result in an Err.
-pub async fn format_display_name(
-    db: &Database,
-    user_id: &str,
-    server_id: Option<&str>,
-) -> Result<String> {
-    if let Some(server_id) = server_id {
-        let member = db.fetch_member(server_id, user_id).await?;
-        if let Some(nick) = member.nickname {
-            return Ok(nick);
-        }
-    }
-
-    let user = db.fetch_user(user_id).await?;
-    if let Some(display) = user.display_name {
-        return Ok(display);
-    }
-    Ok(format!("{}#{}", user.username, user.discriminator))
-}
@@ -1,9 +1,7 @@
 pub mod bridge;
 pub mod bulk_permissions;
-mod funcs;
 pub mod idempotency;
 pub mod permissions;
 pub mod reference;
 pub mod test_fixtures;
-
-pub use funcs::*;
+pub mod oauth2;
@@ -0,0 +1,17 @@
+use std::marker::PhantomData;
+
+use axum::{extract::FromRequestParts, http::request::Parts};
+use revolt_result::{Error, Result};
+
+use super::{OAuth2Scoped, scopes::OAuth2Scope};
+
+#[rocket::async_trait]
+impl<S: Send + Sync, Scope: OAuth2Scope> FromRequestParts<S> for OAuth2Scoped<Scope> {
+    type Rejection = Error;
+
+    async fn from_request_parts(parts: &mut Parts, _state: &S) -> Result<Self> {
+        parts.extensions.insert(Scope::SCOPE);
+
+        Ok(OAuth2Scoped { _scope: PhantomData })
+    }
+}
@@ -0,0 +1,120 @@
+use chrono::{TimeDelta, Utc};
+use jsonwebtoken::{decode, encode, errors::Error, DecodingKey, EncodingKey, Header, Validation};
+use redis_kiss::AsyncCommands;
+use revolt_models::v0;
+use revolt_result::Result;
+use serde::{Deserialize, Serialize};
+
+pub mod scopes;
+pub use scopes::OAuth2Scoped;
+
+#[cfg(feature = "rocket")]
+pub mod rocket;
+
+#[cfg(feature = "axum")]
+pub mod axum;
+
+pub use jsonwebtoken::errors::{Error as JWTError, ErrorKind as JWTErrorKind};
+use ulid::Ulid;
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
+pub enum TokenType {
+    Auth,
+    Access,
+    Refresh,
+}
+
+impl TokenType {
+    pub fn lifetime(self) -> TimeDelta {
+        match self {
+            TokenType::Access => TimeDelta::weeks(1),
+            TokenType::Auth => TimeDelta::minutes(5),
+            TokenType::Refresh => TimeDelta::weeks(4),
+        }
+    }
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct Claims {
+    pub jti: String,
+    pub sub: String,
+    pub exp: i64,
+
+    pub r#type: TokenType,
+    pub client_id: String,
+    pub scopes: Vec<v0::OAuth2Scope>,
+    pub redirect_uri: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub code_challange_method: Option<v0::OAuth2CodeChallangeMethod>,
+}
+
+#[allow(clippy::too_many_arguments)]
+pub fn encode_token(
+    token_secret: &str,
+    token_type: TokenType,
+    user_id: String,
+    client_id: String,
+    redirect_uri: String,
+    scopes: Vec<v0::OAuth2Scope>,
+    code_challange_method: Option<v0::OAuth2CodeChallangeMethod>,
+) -> Result<String, Error> {
+    let now = Utc::now();
+
+    let exp = now.checked_add_signed(token_type.lifetime()).unwrap();
+
+    println!("{now:?} {exp:}");
+
+    let claims = Claims {
+        jti: Ulid::new().to_string(),
+        sub: user_id,
+        exp: exp.timestamp(),
+
+        r#type: token_type,
+        client_id,
+        scopes,
+        redirect_uri,
+        code_challange_method,
+    };
+
+    let encoding_key = EncodingKey::from_secret(token_secret.as_bytes());
+
+    encode(&Header::default(), &claims, &encoding_key)
+}
+
+pub fn decode_token(token_secret: &str, code: &str) -> Result<Claims, Error> {
+    let decoding_key = DecodingKey::from_secret(token_secret.as_bytes());
+
+    let data = decode(
+        code,
+        &decoding_key,
+        &Validation::new(jsonwebtoken::Algorithm::HS256),
+    )?;
+
+    Ok(data.claims)
+}
+
+pub async fn add_code_challange(token: &str, code_challenge: &str) -> Result<()> {
+    let mut conn = redis_kiss::get_connection()
+        .await
+        .map_err(|_| create_error!(InternalError))?;
+
+    conn.pset_ex::<_, _, ()>(
+        format!("oauth2:{token}:code_challenge"),
+        code_challenge,
+        TokenType::Access.lifetime().num_milliseconds() as usize,
+    )
+    .await
+    .map_err(|_| create_error!(InternalError))?;
+
+    Ok(())
+}
+
+pub async fn get_code_challange(token: &str) -> Result<Option<String>> {
+    let mut conn = redis_kiss::get_connection()
+        .await
+        .map_err(|_| create_error!(InternalError))?;
+
+    conn.get(format!("oauth2:{token}:code_challenge"))
+        .await
+        .map_err(|_| create_error!(InternalError))
+}
@@ -0,0 +1,53 @@
+use std::{convert::Infallible, marker::PhantomData};
+
+use revolt_okapi::openapi3::{OAuthFlows, SecurityScheme, SecuritySchemeData};
+use revolt_rocket_okapi::request::{OpenApiFromRequest, RequestHeaderInput};
+use rocket::{request::{self, FromRequest}, Request};
+
+use super::{OAuth2Scoped, scopes::OAuth2Scope};
+
+
+#[rocket::async_trait]
+impl<'r, Scope: OAuth2Scope> FromRequest<'r> for OAuth2Scoped<Scope> {
+    type Error = Infallible;
+
+    async fn from_request(request: &'r Request<'_>) -> request::Outcome<Self, Self::Error> {
+        request.local_cache(|| Some(Scope::SCOPE));
+
+        request::Outcome::Success(OAuth2Scoped { _scope: PhantomData })
+    }
+}
+
+impl<'r, Scope: OAuth2Scope> OpenApiFromRequest<'r> for OAuth2Scoped<Scope> {
+    fn from_request_input(
+        _gen: &mut revolt_rocket_okapi::r#gen::OpenApiGenerator,
+        _name: String,
+        _required: bool,
+    ) -> revolt_rocket_okapi::Result<revolt_rocket_okapi::request::RequestHeaderInput> {
+        Ok(RequestHeaderInput::Security(
+            "OAuth2".to_owned(),
+            SecurityScheme {
+                description: None,
+                extensions: Default::default(),
+                data: SecuritySchemeData::OAuth2 {
+                    flows: OAuthFlows::AuthorizationCode {
+                        authorization_url: "todo".to_string(),
+                        token_url: "todo".to_string(),
+                        refresh_url: Some("todo".to_string()),
+                        scopes: revolt_okapi::map! {
+                            "read:identify".to_string() => "".to_string(),
+                            "read:servers".to_string() => "".to_string(),
+                            "write:files".to_string() => "".to_string(),
+                            "events".to_string() => "".to_string(),
+                            "full".to_string() => "".to_string(),
+                        },
+                        extensions: Default::default()
+                    }
+                }
+            },
+            revolt_okapi::map! {
+                "OAuth2".to_owned() => vec![Scope::MODEL.to_string()]
+            },
+        ))
+    }
+}
@@ -0,0 +1,29 @@
+use std::marker::PhantomData;
+
+pub struct OAuth2Scoped<Scope> {
+    pub(crate) _scope: PhantomData<Scope>
+}
+
+pub trait OAuth2Scope {
+    const SCOPE: crate::OAuth2Scope;
+    const MODEL: revolt_models::v0::OAuth2Scope;
+}
+
+macro_rules! define_oauth2_scope {
+    ($struct_name:ident) => {
+        pub struct $struct_name;
+
+        impl OAuth2Scope for $struct_name {
+            const SCOPE: crate::OAuth2Scope = crate::OAuth2Scope::$struct_name;
+            const MODEL: revolt_models::v0::OAuth2Scope = revolt_models::v0::OAuth2Scope::$struct_name;
+        }
+    };
+}
+
+// This must match the OAuth2Scope enum
+// TODO: automatically sync this
+define_oauth2_scope!(ReadIdentify);
+define_oauth2_scope!(ReadServers);
+define_oauth2_scope!(WriteFiles);
+define_oauth2_scope!(Events);
+define_oauth2_scope!(Full);
@@ -185,26 +185,9 @@ impl PermissionQuery for DatabasePermissionQuery<'_> {
        }
    }

-    async fn do_we_have_publish_overwrites(&mut self) -> bool {
-        if let Some(member) = &self.member {
-            member.can_publish
-        } else {
-            true
-        }
-    }
-
-    async fn do_we_have_receive_overwrites(&mut self) -> bool {
-        if let Some(member) = &self.member {
-            member.can_receive
-        } else {
-            true
-        }
-    }
-
    // * For calculating channel permission

    /// Get the type of the channel
-    #[allow(deprecated)]
    async fn get_channel_type(&mut self) -> ChannelType {
        if let Some(channel) = &self.channel {
            match channel {
@@ -216,7 +199,9 @@ impl PermissionQuery for DatabasePermissionQuery<'_> {
                Cow::Borrowed(Channel::SavedMessages { .. })
                | Cow::Owned(Channel::SavedMessages { .. }) => ChannelType::SavedMessages,
                Cow::Borrowed(Channel::TextChannel { .. })
-                | Cow::Owned(Channel::TextChannel { .. }) => ChannelType::ServerChannel,
+                | Cow::Owned(Channel::TextChannel { .. })
+                | Cow::Borrowed(Channel::VoiceChannel { .. })
+                | Cow::Owned(Channel::VoiceChannel { .. }) => ChannelType::ServerChannel,
            }
        } else {
            ChannelType::Unknown
@@ -240,6 +225,14 @@ impl PermissionQuery for DatabasePermissionQuery<'_> {
                | Cow::Owned(Channel::TextChannel {
                    default_permissions,
                    ..
+                })
+                | Cow::Borrowed(Channel::VoiceChannel {
+                    default_permissions,
+                    ..
+                })
+                | Cow::Owned(Channel::VoiceChannel {
+                    default_permissions,
+                    ..
                }) => default_permissions.unwrap_or_default().into(),
                _ => Default::default(),
            }
@@ -257,6 +250,12 @@ impl PermissionQuery for DatabasePermissionQuery<'_> {
                })
                | Cow::Owned(Channel::TextChannel {
                    role_permissions, ..
+                })
+                | Cow::Borrowed(Channel::VoiceChannel {
+                    role_permissions, ..
+                })
+                | Cow::Owned(Channel::VoiceChannel {
+                    role_permissions, ..
                }) => {
                    if let Some(server) = &self.server {
                        let member_roles = self
@@ -344,10 +343,11 @@ impl PermissionQuery for DatabasePermissionQuery<'_> {
    /// (this will only ever be called for server channels, use unimplemented!() for other code paths)
    async fn set_server_from_channel(&mut self) {
        if let Some(channel) = &self.channel {
-            #[allow(deprecated)]
            match channel {
                Cow::Borrowed(Channel::TextChannel { server, .. })
-                | Cow::Owned(Channel::TextChannel { server, .. }) => {
+                | Cow::Owned(Channel::TextChannel { server, .. })
+                | Cow::Borrowed(Channel::VoiceChannel { server, .. })
+                | Cow::Owned(Channel::VoiceChannel { server, .. }) => {
                    if let Some(known_server) =
                        // I'm not sure why I can't just pattern match both at once here?
                        // It throws some weird error and the provided fix doesn't work :/
@@ -1,696 +0,0 @@
-use std::fmt::{Display, Write};
-
-use crate::{
-    events::client::EventV1,
-    models::{Channel, User},
-    util::{permissions::DatabasePermissionQuery, reference::Reference},
-    Database, Server,
-};
-use iso8601_timestamp::{Duration, Timestamp};
-use livekit_protocol::ParticipantPermission;
-use redis_kiss::{
-    get_connection as _get_connection,
-    redis::{FromRedisValue, Pipeline, RedisError, RedisWrite, ToRedisArgs, Value},
-    AsyncCommands, Conn,
-};
-use revolt_config::FeaturesLimits;
-use revolt_models::v0::{self, PartialUserVoiceState, UserVoiceState};
-use revolt_permissions::{calculate_channel_permissions, ChannelPermission, PermissionValue};
-use revolt_result::{create_error, Result, ToRevoltError};
-
-mod voice_client;
-pub use voice_client::VoiceClient;
-
-async fn get_connection() -> Result<Conn> {
-    _get_connection()
-        .await
-        .map_err(|_| create_error!(InternalError))
-}
-
-pub async fn raise_if_in_voice(user: &User, channel: &UserVoiceChannel) -> Result<()> {
-    let mut conn = get_connection().await?;
-
-    if user.bot.is_some() {
-        // bots can be in as many voice channels as it wants so we just check if its already connected to the one its trying to connect to
-        if conn
-            .sismember(format!("vc:{}", &user.id), channel)
-            .await
-            .to_internal_error()?
-        {
-            return Err(create_error!(AlreadyConnected));
-        };
-    } else if conn
-        .scard::<_, u32>(format!("vc:{}", &user.id)) // check if the current vc set is empty
-        .await
-        .to_internal_error()?
-        > 0
-    {
-        return Err(create_error!(AlreadyConnected));
-    };
-
-    Ok(())
-}
-
-pub async fn set_channel_node(channel_id: &str, node: &str) -> Result<()> {
-    get_connection()
-        .await?
-        .set(format!("node:{channel_id}"), node)
-        .await
-        .to_internal_error()
-}
-
-pub async fn get_channel_node(channel_id: &str) -> Result<Option<String>> {
-    get_connection()
-        .await?
-        .get(format!("node:{channel_id}"))
-        .await
-        .to_internal_error()
-}
-
-pub async fn delete_channel_node(channel_id: &str) -> Result<()> {
-    get_connection()
-        .await?
-        .del(format!("node:{channel_id}"))
-        .await
-        .to_internal_error()
-}
-
-pub async fn get_user_voice_channels(user_id: &str) -> Result<Vec<UserVoiceChannel>> {
-    get_connection()
-        .await?
-        .smembers(format!("vc:{user_id}"))
-        .await
-        .to_internal_error()
-}
-
-pub async fn set_user_moved_from_voice(
-    old_channel_id: &str,
-    new_channel: &UserVoiceChannel,
-    user_id: &str,
-) -> Result<()> {
-    get_connection()
-        .await?
-        .set_ex(
-            format!("moved_from:{user_id}:{old_channel_id}"),
-            new_channel,
-            10,
-        )
-        .await
-        .to_internal_error()
-}
-
-pub async fn get_user_moved_from_voice(channel_id: &str, user_id: &str) -> Result<Option<String>> {
-    get_connection()
-        .await?
-        .get_del(format!("moved_from:{user_id}:{channel_id}"))
-        .await
-        .to_internal_error()
-}
-
-pub async fn set_user_moved_to_voice(
-    new_channel_id: &str,
-    old_channel: &UserVoiceChannel,
-    user_id: &str,
-) -> Result<()> {
-    get_connection()
-        .await?
-        .set_ex(
-            format!("moved_to:{user_id}:{new_channel_id}"),
-            old_channel,
-            10,
-        )
-        .await
-        .to_internal_error()
-}
-
-pub async fn get_user_moved_to_voice(
-    channel_id: &str,
-    user_id: &str,
-) -> Result<Option<UserVoiceChannel>> {
-    get_connection()
-        .await?
-        .get_del(format!("moved_to:{user_id}:{channel_id}"))
-        .await
-        .to_internal_error()
-}
-
-pub async fn is_in_voice_channel(user_id: &str, channel: &UserVoiceChannel) -> Result<bool> {
-    get_connection()
-        .await?
-        .sismember(format!("vc:{user_id}"), channel)
-        .await
-        .to_internal_error()
-}
-
-pub async fn get_user_voice_channel_in_server(
-    user_id: &str,
-    server_id: &str,
-) -> Result<Option<String>> {
-    let mut conn = get_connection().await?;
-
-    let unique_key = format!("{user_id}:{server_id}");
-
-    conn.get(&unique_key).await.to_internal_error()
-}
-
-pub fn get_allowed_sources(
-    limits: &FeaturesLimits,
-    permissions: PermissionValue,
-) -> Vec<&'static str> {
-    let mut allowed_sources = Vec::new();
-
-    if permissions.has(ChannelPermission::Speak as u64) {
-        allowed_sources.push("microphone")
-    };
-
-    if permissions.has(ChannelPermission::Video as u64) && limits.video {
-        allowed_sources.extend(["camera", "screen_share", "screen_share_audio"]);
-    };
-
-    allowed_sources
-}
-
-pub async fn create_voice_state(
-    channel: &UserVoiceChannel,
-    user_id: &str,
-    joined_at: Timestamp,
-) -> Result<UserVoiceState> {
-    let unique_key = format!(
-        "{}:{}",
-        &user_id,
-        channel.server_id.as_ref().unwrap_or(&channel.id)
-    );
-
-    let voice_state = UserVoiceState {
-        joined_at,
-        id: user_id.to_string(),
-        is_receiving: true,
-        is_publishing: false,
-        screensharing: false,
-        camera: false,
-    };
-
-    Pipeline::new()
-        .sadd(format!("vc_members:{}", &channel.id), user_id)
-        .sadd(format!("vc:{user_id}"), channel)
-        .set(&unique_key, &channel.id)
-        .set(
-            format!("joined_at:{unique_key}"),
-            joined_at
-                .duration_since(Timestamp::UNIX_EPOCH)
-                .whole_milliseconds() as i64,
-        )
-        .set(
-            format!("is_publishing:{unique_key}"),
-            voice_state.is_publishing,
-        )
-        .set(
-            format!("is_receiving:{unique_key}"),
-            voice_state.is_receiving,
-        )
-        .set(
-            format!("screensharing:{unique_key}"),
-            voice_state.screensharing,
-        )
-        .set(format!("camera:{unique_key}"), voice_state.camera)
-        .query_async::<_, ()>(&mut get_connection().await?.into_inner())
-        .await
-        .to_internal_error()?;
-
-    Ok(voice_state)
-}
-
-pub async fn delete_voice_state(channel: &UserVoiceChannel, user_id: &str) -> Result<()> {
-    let unique_key = format!(
-        "{}:{}",
-        &user_id,
-        channel.server_id.as_ref().unwrap_or(&channel.id)
-    );
-
-    Pipeline::new()
-        .srem(format!("vc_members:{}", &channel.id), user_id)
-        .srem(format!("vc:{user_id}"), channel)
-        .del(&[
-            format!("joined_at:{unique_key}"),
-            format!("is_publishing:{unique_key}"),
-            format!("is_receiving:{unique_key}"),
-            format!("screensharing:{unique_key}"),
-            format!("camera:{unique_key}"),
-            unique_key.clone(),
-        ])
-        .query_async(&mut get_connection().await?.into_inner())
-        .await
-        .to_internal_error()
-}
-
-pub async fn delete_channel_voice_state(
-    channel: &UserVoiceChannel,
-    user_ids: &[String],
-) -> Result<()> {
-    let parent_id = channel.server_id.as_ref().unwrap_or(&channel.id);
-
-    let mut pipeline = Pipeline::new();
-    pipeline.del(format!("vc_members:{}", &channel.id));
-    pipeline.del(format!("node:{}", &channel.id));
-
-    for user_id in user_ids {
-        let unique_key = format!("{user_id}:{parent_id}");
-
-        pipeline.srem(format!("vc:{user_id}"), channel).del(&[
-            format!("joined_at:{unique_key}"),
-            format!("is_publishing:{unique_key}"),
-            format!("is_receiving:{unique_key}"),
-            format!("screensharing:{unique_key}"),
-            format!("camera:{unique_key}"),
-            unique_key.clone(),
-        ]);
-    }
-
-    pipeline
-        .query_async(&mut get_connection().await?.into_inner())
-        .await
-        .to_internal_error()
-}
-
-pub async fn update_voice_state_tracks(
-    channel: &UserVoiceChannel,
-    user_id: &str,
-    added: bool,
-    track: i32,
-) -> Result<PartialUserVoiceState> {
-    let partial = match track {
-        /* TrackSource::Unknown */ 0 => PartialUserVoiceState::default(),
-        /* TrackSource::Camera */
-        1 => PartialUserVoiceState {
-            camera: Some(added),
-            ..Default::default()
-        },
-        /* TrackSource::Microphone */
-        2 => PartialUserVoiceState {
-            is_publishing: Some(added),
-            ..Default::default()
-        },
-        /* TrackSource::ScreenShare | TrackSource::ScreenShareAudio */
-        3 | 4 => PartialUserVoiceState {
-            screensharing: Some(added),
-            ..Default::default()
-        },
-        _ => unreachable!(),
-    };
-
-    update_voice_state(channel, user_id, &partial).await?;
-
-    Ok(partial)
-}
-
-pub async fn update_voice_state(
-    channel: &UserVoiceChannel,
-    user_id: &str,
-    partial: &PartialUserVoiceState,
-) -> Result<()> {
-    let unique_key = format!(
-        "{}:{}",
-        &user_id,
-        channel.server_id.as_ref().unwrap_or(&channel.id)
-    );
-
-    let mut pipeline = Pipeline::new();
-
-    if let Some(camera) = &partial.camera {
-        pipeline.set(format!("camera:{unique_key}"), camera);
-    };
-
-    if let Some(is_publishing) = &partial.is_publishing {
-        pipeline.set(format!("is_publishing:{unique_key}"), is_publishing);
-    }
-
-    if let Some(is_receiving) = &partial.is_receiving {
-        pipeline.set(format!("is_receiving:{unique_key}"), is_receiving);
-    }
-
-    if let Some(screensharing) = &partial.screensharing {
-        pipeline.set(format!("screensharing:{unique_key}"), screensharing);
-    }
-
-    pipeline
-        .query_async(&mut get_connection().await?.into_inner())
-        .await
-        .to_internal_error()
-}
-
-pub async fn get_voice_channel_members(channel: &UserVoiceChannel) -> Result<Option<Vec<String>>> {
-    get_connection()
-        .await?
-        .smembers::<_, Option<Vec<String>>>(format!("vc_members:{}", &channel.id))
-        .await
-        .to_internal_error()
-        .map(|opt| opt.and_then(|v| if v.is_empty() { None } else { Some(v) }))
-}
-
-pub async fn get_voice_state(
-    channel: &UserVoiceChannel,
-    user_id: &str,
-) -> Result<Option<UserVoiceState>> {
-    let unique_key = format!(
-        "{}:{}",
-        &user_id,
-        channel.server_id.as_ref().unwrap_or(&channel.id)
-    );
-
-    let (joined_at, is_publishing, is_receiving, screensharing, camera) = get_connection()
-        .await?
-        .mget(&[
-            format!("joined_at:{unique_key}"),
-            format!("is_publishing:{unique_key}"),
-            format!("is_receiving:{unique_key}"),
-            format!("screensharing:{unique_key}"),
-            format!("camera:{unique_key}"),
-        ])
-        .await
-        .to_internal_error()?;
-
-    match (
-        joined_at,
-        is_publishing,
-        is_receiving,
-        screensharing,
-        camera,
-    ) {
-        (
-            Some(joined_at),
-            Some(is_publishing),
-            Some(is_receiving),
-            Some(screensharing),
-            Some(camera),
-        ) => Ok(Some(v0::UserVoiceState {
-            joined_at: Timestamp::UNIX_EPOCH
-                .checked_add(Duration::milliseconds(joined_at))
-                .unwrap(),
-            id: user_id.to_string(),
-            is_receiving,
-            is_publishing,
-            screensharing,
-            camera,
-        })),
-        _ => Ok(None),
-    }
-}
-
-pub async fn get_channel_voice_state(
-    channel: &UserVoiceChannel,
-) -> Result<Option<v0::ChannelVoiceState>> {
-    let members = get_voice_channel_members(channel).await?;
-
-    if let Some(members) = members {
-        let mut participants = Vec::with_capacity(members.len());
-
-        for user_id in members {
-            if let Some(voice_state) = get_voice_state(channel, &user_id).await? {
-                participants.push(voice_state);
-            } else {
-                log::info!("Voice state not found but member in voice channel members, removing.");
-
-                delete_voice_state(channel, &user_id).await?;
-            }
-        }
-
-        // In case a user voice state failed to be fetched, the vec's capacity will be larger than the length, shrink it
-        participants.shrink_to_fit();
-
-        Ok(Some(v0::ChannelVoiceState {
-            id: channel.id.clone(),
-            participants,
-        }))
-    } else {
-        Ok(None)
-    }
-}
-
-pub async fn move_user(user: &str, from_channel_id: &str, to_channel_id: &str) -> Result<()> {
-    get_connection()
-        .await?
-        .smove(
-            format!("vc_members:{from_channel_id}"),
-            format!("vc_members:{to_channel_id}"),
-            user,
-        )
-        .await
-        .to_internal_error()
-}
-
-pub async fn sync_voice_permissions(
-    db: &Database,
-    voice_client: &VoiceClient,
-    channel: &Channel,
-    server: Option<&Server>,
-    role_id: Option<&str>,
-) -> Result<()> {
-    let user_voice_channel = UserVoiceChannel::from_channel(channel);
-
-    let Some(node) = get_channel_node(channel.id()).await? else {
-        return Ok(());
-    };
-
-    for user_id in get_voice_channel_members(&user_voice_channel)
-        .await?
-        .iter()
-        .flatten()
-    {
-        let user = Reference::from_unchecked(user_id).as_user(db).await?;
-
-        sync_user_voice_permissions(db, voice_client, &node, &user, channel, server, role_id)
-            .await?;
-    }
-
-    Ok(())
-}
-
-pub async fn sync_user_voice_permissions(
-    db: &Database,
-    voice_client: &VoiceClient,
-    node: &str,
-    user: &User,
-    channel: &Channel,
-    server: Option<&Server>,
-    role_id: Option<&str>,
-) -> Result<()> {
-    let channel_id = channel.id();
-    let server_id = server.as_ref().map(|s| s.id.as_str());
-
-    let member = match server_id {
-        Some(server_id) => Some(
-            Reference::from_unchecked(&user.id)
-                .as_member(db, server_id)
-                .await?,
-        ),
-        None => None,
-    };
-
-    if role_id.is_none_or(|role_id| {
-        member
-            .as_ref()
-            .is_none_or(|member| member.roles.iter().any(|r| r == role_id))
-    }) {
-        let user_voice_channel = UserVoiceChannel::from_channel(channel);
-
-        let Some(voice_state) = get_voice_state(&user_voice_channel, &user.id).await? else {
-            return Ok(());
-        };
-
-        let mut query = DatabasePermissionQuery::new(db, user)
-            .channel(channel)
-            .user(user);
-
-        if let (Some(server), Some(member)) = (server, member.as_ref()) {
-            query = query.member(member).server(server)
-        }
-
-        let permissions = calculate_channel_permissions(&mut query).await;
-        let limits = user.limits().await;
-
-        let mut update_event = PartialUserVoiceState {
-            id: Some(user.id.clone()),
-            ..Default::default()
-        };
-
-        let before = update_event.clone();
-
-        let can_video =
-            limits.video && permissions.has_channel_permission(ChannelPermission::Video);
-        let can_speak = permissions.has_channel_permission(ChannelPermission::Speak);
-        let can_listen = permissions.has_channel_permission(ChannelPermission::Listen);
-
-        update_event.camera = voice_state.camera.then_some(can_video);
-        update_event.screensharing = voice_state.screensharing.then_some(can_video);
-        update_event.is_publishing = voice_state.is_publishing.then_some(can_speak);
-
-        update_voice_state(&user_voice_channel, &user.id, &update_event).await?;
-
-        voice_client
-            .update_permissions(
-                node,
-                user,
-                channel_id,
-                ParticipantPermission {
-                    can_subscribe: can_listen,
-                    can_publish: can_speak,
-                    can_publish_data: can_speak,
-                    ..Default::default()
-                },
-            )
-            .await?;
-
-        if update_event != before {
-            EventV1::UserVoiceStateUpdate {
-                id: user.id.clone(),
-                channel_id: channel_id.to_string(),
-                data: update_event,
-            }
-            .p(channel_id.to_string())
-            .await;
-        };
-    };
-
-    Ok(())
-}
-
-pub async fn set_channel_call_started_system_message(
-    channel_id: &str,
-    message_id: &str,
-) -> Result<()> {
-    get_connection()
-        .await?
-        .set(format!("call_started_message:{channel_id}"), message_id)
-        .await
-        .to_internal_error()
-}
-
-pub async fn take_channel_call_started_system_message(channel_id: &str) -> Result<Option<String>> {
-    get_connection()
-        .await?
-        .get_del(format!("call_started_message:{channel_id}"))
-        .await
-        .to_internal_error()
-}
-
-pub async fn set_call_notification_recipients(
-    channel_id: &str,
-    user_id: &str,
-    recipients: &[String],
-) -> Result<()> {
-    get_connection()
-        .await?
-        .set_ex(
-            format!("call_notification_recipients:{channel_id}-{user_id}"),
-            recipients,
-            10,
-        )
-        .await
-        .to_internal_error()
-}
-
-pub async fn get_call_notification_recipients(
-    channel_id: &str,
-    user_id: &str,
-) -> Result<Option<Vec<String>>> {
-    get_connection()
-        .await?
-        .get_del(format!(
-            "call_notification_recipients:{channel_id}-{user_id}"
-        ))
-        .await
-        .to_internal_error()
-}
-
-pub async fn remove_user_from_voice_channels(
-    voice_client: &VoiceClient,
-    user_id: &str,
-) -> Result<()> {
-    for channel in get_user_voice_channels(user_id).await? {
-        remove_user_from_voice_channel(voice_client, &channel, user_id).await?;
-    }
-
-    Ok(())
-}
-
-pub async fn remove_user_from_voice_channel(
-    voice_client: &VoiceClient,
-    channel: &UserVoiceChannel,
-    user_id: &str,
-) -> Result<()> {
-    if let Some(node) = get_channel_node(&channel.id).await? {
-        let _ = voice_client.remove_user(&node, user_id, &channel.id).await;
-    }
-
-    delete_voice_state(channel, user_id).await?;
-
-    Ok(())
-}
-
-pub async fn delete_voice_channel(
-    voice_client: &VoiceClient,
-    channel: &UserVoiceChannel,
-) -> Result<()> {
-    if let Some(users) = get_voice_channel_members(channel).await? {
-        let node = get_channel_node(&channel.id).await?.unwrap();
-        voice_client.delete_room(&node, &channel.id).await?;
-
-        delete_channel_voice_state(channel, &users).await?;
-    };
-
-    Ok(())
-}
-
-#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
-pub struct RoomMetadata {
-    pub server: Option<String>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct UserVoiceChannel {
-    pub id: String,
-    pub server_id: Option<String>,
-}
-
-impl UserVoiceChannel {
-    pub fn from_string(input: String) -> Self {
-        let mut parts = input.splitn(2, '-');
-
-        Self {
-            id: parts.next().unwrap().to_string(),
-            server_id: parts.next().map(ToString::to_string),
-        }
-    }
-
-    pub fn from_channel(channel: &Channel) -> Self {
-        Self {
-            id: channel.id().to_string(),
-            server_id: channel.server().map(ToString::to_string),
-        }
-    }
-}
-
-impl Display for UserVoiceChannel {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.write_str(&self.id)?;
-
-        if let Some(server_id) = &self.server_id {
-            f.write_char('-')?;
-            f.write_str(server_id)?
-        };
-
-        Ok(())
-    }
-}
-
-impl ToRedisArgs for UserVoiceChannel {
-    fn write_redis_args<W: ?Sized + RedisWrite>(&self, out: &mut W) {
-        out.write_arg_fmt(self);
-    }
-}
-
-impl FromRedisValue for UserVoiceChannel {
-    fn from_redis_value(v: &Value) -> Result<Self, RedisError> {
-        String::from_redis_value(v).map(UserVoiceChannel::from_string)
-    }
-}
@@ -1,162 +0,0 @@
-use crate::{
-    models::{Channel, User},
-    voice::RoomMetadata,
-    Database,
-};
-use livekit_api::{
-    access_token::{AccessToken, VideoGrants},
-    services::room::{CreateRoomOptions, RoomClient as InnerRoomClient, UpdateParticipantOptions},
-};
-use livekit_protocol::{ParticipantInfo, ParticipantPermission, Room};
-use revolt_config::{config, LiveKitNode};
-use revolt_permissions::{ChannelPermission, PermissionValue};
-use revolt_result::{create_error, Result, ToRevoltError};
-use std::{collections::HashMap, time::Duration};
-
-use super::get_allowed_sources;
-
-#[derive(Debug)]
-pub struct RoomClient {
-    pub client: InnerRoomClient,
-    pub node: LiveKitNode,
-}
-
-#[derive(Debug)]
-pub struct VoiceClient {
-    pub rooms: HashMap<String, RoomClient>,
-}
-
-impl VoiceClient {
-    pub fn new(nodes: HashMap<String, LiveKitNode>) -> Self {
-        Self {
-            rooms: nodes
-                .into_iter()
-                .map(|(name, node)| {
-                    (
-                        name,
-                        RoomClient {
-                            client: InnerRoomClient::with_api_key(
-                                &node.url,
-                                &node.key,
-                                &node.secret,
-                            ),
-                            node,
-                        },
-                    )
-                })
-                .collect(),
-        }
-    }
-
-    pub fn is_enabled(&self) -> bool {
-        !self.rooms.is_empty()
-    }
-
-    pub async fn from_revolt_config() -> Self {
-        let config = config().await;
-
-        Self::new(config.api.livekit.nodes.clone())
-    }
-
-    pub fn get_node(&self, name: &str) -> Result<&RoomClient> {
-        self.rooms
-            .get(name)
-            .ok_or_else(|| create_error!(UnknownNode))
-    }
-
-    pub async fn create_token(
-        &self,
-        node: &str,
-        db: &Database,
-        user: &User,
-        permissions: PermissionValue,
-        channel: &Channel,
-    ) -> Result<String> {
-        let room = self.get_node(node)?;
-
-        let limits = user.limits().await;
-        let allowed_sources = get_allowed_sources(&limits, permissions);
-
-        AccessToken::with_api_key(&room.node.key, &room.node.secret)
-            .with_name(&format!("{}#{}", user.username, user.discriminator))
-            .with_identity(&user.id)
-            .with_metadata(
-                &serde_json::to_string(&user.clone().into(db, None).await).to_internal_error()?,
-            )
-            .with_ttl(Duration::from_secs(10))
-            .with_grants(VideoGrants {
-                room_join: true,
-                can_publish: true,
-                can_publish_data: false,
-                can_publish_sources: allowed_sources
-                    .into_iter()
-                    .map(ToString::to_string)
-                    .collect(),
-                can_subscribe: permissions.has_channel_permission(ChannelPermission::Listen),
-                room: channel.id().to_string(),
-                ..Default::default()
-            })
-            .to_jwt()
-            .to_internal_error()
-    }
-
-    pub async fn create_room(&self, node: &str, channel: &Channel) -> Result<Room> {
-        let room = self.get_node(node)?;
-
-        let metadata = RoomMetadata {
-            server: channel.server().map(|id| id.to_string()),
-        };
-
-        room.client
-            .create_room(
-                channel.id(),
-                CreateRoomOptions {
-                    empty_timeout: 5 * 60, // 5 minutes,
-                    metadata: serde_json::to_string(&metadata).to_internal_error()?,
-                    ..Default::default()
-                },
-            )
-            .await
-            .to_internal_error()
-    }
-
-    pub async fn update_permissions(
-        &self,
-        node: &str,
-        user: &User,
-        channel_id: &str,
-        new_permissions: ParticipantPermission,
-    ) -> Result<ParticipantInfo> {
-        let room = self.get_node(node)?;
-
-        room.client
-            .update_participant(
-                channel_id,
-                &user.id,
-                UpdateParticipantOptions {
-                    permission: Some(new_permissions),
-                    ..Default::default()
-                },
-            )
-            .await
-            .to_internal_error()
-    }
-
-    pub async fn remove_user(&self, node: &str, user_id: &str, channel_id: &str) -> Result<()> {
-        let room = self.get_node(node)?;
-
-        room.client
-            .remove_participant(channel_id, user_id)
-            .await
-            .to_internal_error()
-    }
-
-    pub async fn delete_room(&self, node: &str, channel_id: &str) -> Result<()> {
-        let room = self.get_node(node)?;
-
-        room.client
-            .delete_room(channel_id)
-            .await
-            .to_internal_error()
-    }
-}
@@ -1,7 +1,7 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 <html>
  <head>
-    <!-- Compiled with Bootstrap Email version: 1.6.0 --><meta http-equiv="x-ua-compatible" content="ie=edge">
+    <!-- Compiled with Bootstrap Email version: 1.5.1 --><meta http-equiv="x-ua-compatible" content="ie=edge">
    <meta name="x-apple-disable-message-reformatting">
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta name="format-detection" content="telephone=no, date=no, address=no, email=no">
@@ -42,7 +42,7 @@
                              <tbody>
                                <tr>
                                  <td style="line-height: 24px; font-size: 16px; margin: 0;" align="left">
-                                    <img alt="Stoat Logo" class="w-24" src="https://stoat.chat/favicon.svg" style="height: auto; line-height: 100%; outline: none; text-decoration: none; display: block; width: 96px; border-style: none; border-width: 0;" width="96">
+                                    <img alt="Revolt Logo" class="w-24" src="https://app.revolt.chat/assets/logo_round.png" style="height: auto; line-height: 100%; outline: none; text-decoration: none; display: block; width: 96px; border-style: none; border-width: 0;" width="96">
                                  </td>
                                </tr>
                              </tbody>
@@ -107,7 +107,7 @@
                            </table>
                            <div class="text-muted text-center" style="color: #718096;" align="center">
                              This email is intended for {{email}}<br>
-                              Sent from Stoat<br>
+                              Sent from Revolt<br>
                              Made in Europe
                            </div>
                            <table class="s-6 w-full" role="presentation" border="0" cellpadding="0" cellspacing="0" style="width: 100%;" width="100%">
@@ -1,37 +1,38 @@
 <html>
-
-<head>
-  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-  <style>
-    /* Add custom classes and styles that you want inlined here */
-  </style>
-</head>
-
-<body class="bg-light">
-  <div class="container">
-    <img alt="Stoat Logo" class="ax-center my-10 w-24" src="https://stoat.chat/favicon.svg" />
-    <div class="card p-6 p-lg-10 space-y-4">
-      <h1 class="h3 fw-700">Account Deletion</h1>
-      <p>
-        You requested to have your account deleted, if you did not perform
-        this action please take measures to secure your account immediately.
-      </p>
-      <a class="btn btn-primary p-3 fw-700" href="{{url}}">Confirm</a>
+  <head>
+    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+    <style>
+      /* Add custom classes and styles that you want inlined here */
+    </style>
+  </head>
+  <body class="bg-light">
+    <div class="container">
+      <img
+        alt="Revolt Logo"
+        class="ax-center my-10 w-24"
+        src="https://app.revolt.chat/assets/logo_round.png"
+      />
+      <div class="card p-6 p-lg-10 space-y-4">
+        <h1 class="h3 fw-700">Account Deletion</h1>
+        <p>
+          You requested to have your account deleted, if you did not perform
+          this action please take measures to secure your account immediately.
+        </p>
+        <a class="btn btn-primary p-3 fw-700" href="{{url}}">Confirm</a>
+      </div>
+      <div class="text-muted text-center my-6">
+        This email is intended for {{email}}<br />
+        Sent from Revolt<br />
+        Made in Europe
+      </div>
+      <div class="text-muted text-xs my-6 ax-center">
+        Revolt Platforms Ltd. is a company incorporated and registered under the
+        laws of England and Wales.<br />
+        Registered Company Number: 16260658<br />
+        Registered Office:<br />
+        Suite 5703 Unit 3A, 34-35 Hatton Garden,<br />
+        Holborn, United Kingdom, EC1N 8DX
+      </div>
    </div>
-    <div class="text-muted text-center my-6">
-      This email is intended for {{email}}<br />
-      Sent from Stoat<br />
-      Made in Europe
-    </div>
-    <div class="text-muted text-xs my-6 ax-center">
-      Revolt Platforms Ltd. is a company incorporated and registered under the
-      laws of England and Wales.<br />
-      Registered Company Number: 16260658<br />
-      Registered Office:<br />
-      Suite 5703 Unit 3A, 34-35 Hatton Garden,<br />
-      Holborn, United Kingdom, EC1N 8DX
-    </div>
-  </div>
-</body>
-
-</html>
+  </body>
+</html>
@@ -3,7 +3,7 @@ You requested to have your account deleted, if you did not perform this action p
 Please navigate to: {{url}}

 This email is intended for {{email}}
-Sent by Stoat
+Sent by Revolt
 Made in Europe

 Revolt Platforms Ltd. is a company incorporated and registered under the laws of England and Wales.
Author	SHA1	Message	Date
Zomatree	6043ba6004	Merge branch 'main' into feat/oauth2	2025-11-03 03:28:19 +00:00
Zomatree	67773d3e43	chore: sync branch with main	2025-08-18 02:14:36 +01:00
Zomatree	14ea180683	refactor: simplify scope struct macro	2025-08-18 01:58:15 +01:00
Zomatree	83c15404a5	fix: use correct key name for auth bots collection	2025-08-18 01:58:15 +01:00
Zomatree	9d4bcb5e3d	chore: rework oauth2 route scoping	2025-08-18 01:58:15 +01:00
Zomatree	f895ca7b23	feat: allow connecting to ws via oauth2	2025-08-18 01:58:15 +01:00
Zomatree	ef65223c89	feat: initial work on refresh tokens	2025-08-18 01:58:14 +01:00
Zomatree	660e646b2b	feat: initial oauth2 token revoking	2025-08-18 01:58:14 +01:00
Zomatree	5a5f84f207	fix: add more oauth2 checks	2025-08-18 01:58:14 +01:00
Zomatree	11eee02cfe	feat: allowed scopes	2025-08-18 01:58:14 +01:00
Zomatree	1e5b27ff9e	fix(oauth2): use public bot	2025-08-18 01:58:14 +01:00
Zomatree	3ae25fbcfe	fix(oauth2): fix spec discrepancies	2025-08-18 01:58:14 +01:00
Zomatree	9e05e5be7e	feat: initial oauth2 implementation	2025-08-18 01:58:14 +01:00