feat: initiate mongo replset by default

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

.github/ISSUE_TEMPLATE/bug.yml

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

.github/workflows/book.yml

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

.github/workflows/docker.yaml

@@ -5,19 +5,22 @@ on:
     tags:
       - "*"
   pull_request:
-    branches:
-      - "main"
     paths:
       - "Dockerfile"
+  workflow_dispatch:
 
 permissions:
   contents: read
   packages: write
 
+concurrency:
+  group: ${{ github.head_ref || github.ref }}
+  cancel-in-progress: true
+
 jobs:
   base:
     name: Test base image build
-    runs-on: ubuntu-latest
+    runs-on: arc-runner-set
     if: github.event_name == 'pull_request'
     steps:
       # Configure build environment
@@ -38,7 +41,7 @@ jobs:
           cache-to: type=gha,scope=buildx-base-multi-arch,mode=max
 
   publish:
-    runs-on: self-hosted
+    runs-on: arc-runner-set
     if: github.event_name != 'pull_request'
     name: Publish Docker images
     steps:
@@ -49,13 +52,6 @@ jobs:
         uses: docker/setup-buildx-action@v2
 
       # Authenticate with Docker Hub and GHCR
-      - name: Login to DockerHub
-        uses: docker/login-action@v2
-        with:
-          registry: docker.io
-          username: ${{ secrets.DOCKERHUB_USERNAME }}
-          password: ${{ secrets.DOCKERHUB_TOKEN }}
-
       - name: Login to Github Container Registry
         uses: docker/login-action@v2
         with:
@@ -72,14 +68,13 @@ jobs:
           platforms: linux/amd64,linux/arm64
           tags: ghcr.io/${{ github.repository_owner }}/base:latest
 
-      # revoltchat/server
+      # stoatchat/api
       - name: Docker meta
         id: meta-delta
         uses: docker/metadata-action@v4
         with:
           images: |
-            docker.io/revoltchat/server
-            ghcr.io/revoltchat/server
+            ghcr.io/stoatchat/api
       - name: Publish
         uses: docker/build-push-action@v4
         with:
@@ -92,14 +87,13 @@ jobs:
             BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
           labels: ${{ steps.meta-delta.outputs.labels }}
 
-      # revoltchat/bonfire
+      # stoatchat/events
       - name: Docker meta
         id: meta-bonfire
         uses: docker/metadata-action@v4
         with:
           images: |
-            docker.io/revoltchat/bonfire
-            ghcr.io/revoltchat/bonfire
+            ghcr.io/stoatchat/events
       - name: Publish
         uses: docker/build-push-action@v4
         with:
@@ -112,14 +106,13 @@ jobs:
             BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
           labels: ${{ steps.meta-bonfire.outputs.labels }}
 
-      # revoltchat/autumn
+      # stoatchat/file-server
       - name: Docker meta
         id: meta-autumn
         uses: docker/metadata-action@v4
         with:
           images: |
-            docker.io/revoltchat/autumn
-            ghcr.io/revoltchat/autumn
+            ghcr.io/stoatchat/file-server
       - name: Publish
         uses: docker/build-push-action@v4
         with:
@@ -132,14 +125,13 @@ jobs:
             BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
           labels: ${{ steps.meta-autumn.outputs.labels }}
 
-      # revoltchat/january
+      # stoatchat/proxy
       - name: Docker meta
         id: meta-january
         uses: docker/metadata-action@v4
         with:
           images: |
-            docker.io/revoltchat/january
-            ghcr.io/revoltchat/january
+            ghcr.io/stoatchat/proxy
       - name: Publish
         uses: docker/build-push-action@v4
         with:
@@ -152,14 +144,32 @@ jobs:
             BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
           labels: ${{ steps.meta-january.outputs.labels }}
 
-      # revoltchat/crond
+      # stoatchat/gifbox
+      - name: Docker meta
+        id: meta-gifbox
+        uses: docker/metadata-action@v4
+        with:
+          images: |
+            ghcr.io/stoatchat/gifbox
+      - name: Publish
+        uses: docker/build-push-action@v4
+        with:
+          context: .
+          push: true
+          platforms: linux/amd64,linux/arm64
+          file: crates/services/gifbox/Dockerfile
+          tags: ${{ steps.meta-gifbox.outputs.tags }}
+          build-args: |
+            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
+          labels: ${{ steps.meta-gifbox.outputs.labels }}
+
+      # stoatchat/crond
       - name: Docker meta
         id: meta-crond
         uses: docker/metadata-action@v4
         with:
           images: |
-            docker.io/revoltchat/crond
-            ghcr.io/revoltchat/crond
+            ghcr.io/stoatchat/crond
       - name: Publish
         uses: docker/build-push-action@v4
         with:
@@ -172,14 +182,13 @@ jobs:
             BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
           labels: ${{ steps.meta-crond.outputs.labels }}
 
-      # revoltchat/pushd
+      # stoatchat/pushd
       - name: Docker meta
         id: meta-pushd
         uses: docker/metadata-action@v4
         with:
           images: |
-            docker.io/revoltchat/pushd
-            ghcr.io/revoltchat/pushd
+            ghcr.io/stoatchat/pushd
       - name: Publish
         uses: docker/build-push-action@v4
         with:
@@ -191,3 +200,22 @@ 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 }}

.github/workflows/docs-test.yml

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

.github/workflows/docs.yml

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

.github/workflows/git-town.yml

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

.github/workflows/publish-crates.yml

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

.github/workflows/release-please.yml

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

.github/workflows/release-webhook.yml

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

.github/workflows/rust.yaml

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

.github/workflows/triage_issue.yml

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

.github/workflows/triage_pr.yml

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

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

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

.gitignore

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

.mise/config.toml

@@ -0,0 +1,19 @@
+[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:*" }]

.mise/tasks/build

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

.mise/tasks/check

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

.mise/tasks/docker/start

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

.mise/tasks/docker/stop

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

.mise/tasks/docs/_default

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

.mise/tasks/docs/build

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

.mise/tasks/docs/install

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

.mise/tasks/publish

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

.mise/tasks/service/api

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

.mise/tasks/service/crond

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

.mise/tasks/service/events

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

.mise/tasks/service/files

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

.mise/tasks/service/gifbox

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

.mise/tasks/service/proxy

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

.mise/tasks/service/pushd

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

.mise/tasks/test

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

.release-please-manifest.json

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

CHANGELOG.md

@@ -0,0 +1,149 @@
+# 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` -> `Stoat` in email titles/desc. ([#508](https://github.com/stoatchat/stoatchat/issues/508)) ([84483ce](https://github.com/stoatchat/stoatchat/commit/84483cee7af3e5dfa16f7fe13e334c4d9f5abd60))
+
+## [0.10.2](https://github.com/stoatchat/stoatchat/compare/v0.10.1...v0.10.2) (2026-01-25)
+
+
+### Bug Fixes
+
+* thumbnailification requires rgb8/rgba8 ([#505](https://github.com/stoatchat/stoatchat/issues/505)) ([413aa04](https://github.com/stoatchat/stoatchat/commit/413aa04dcaf8bff3935ed1e5f31432e11a03ce6f))
+
+## [0.10.1](https://github.com/stoatchat/stoatchat/compare/v0.10.0...v0.10.1) (2026-01-25)
+
+
+### Bug Fixes
+
+* use Rust 1.92.0 for Docker build ([#503](https://github.com/stoatchat/stoatchat/issues/503)) ([98da8a2](https://github.com/stoatchat/stoatchat/commit/98da8a28a0aa2fee4e8eee1d86bd7c49e3187477))
+
+## [0.10.0](https://github.com/stoatchat/stoatchat/compare/v0.9.4...v0.10.0) (2026-01-25)
+
+
+### Features
+
+* allow kicking members from voice channels ([#495](https://github.com/stoatchat/stoatchat/issues/495)) ([0dc5442](https://github.com/stoatchat/stoatchat/commit/0dc544249825a49c793309edee5ec1838458a6da))
+* repository architecture for files crate w. added tests ([#498](https://github.com/stoatchat/stoatchat/issues/498)) ([01ded20](https://github.com/stoatchat/stoatchat/commit/01ded209c62208fc906d6aab9b08c04e860e10ef))
+
+
+### Bug Fixes
+
+* expose ratelimit headers via cors ([#496](https://github.com/stoatchat/stoatchat/issues/496)) ([a1a2125](https://github.com/stoatchat/stoatchat/commit/a1a21252d0ad58937e41f16e5fb86f96bebd2a51))
+
+## [0.9.4](https://github.com/stoatchat/stoatchat/compare/v0.9.3...v0.9.4) (2026-01-10)
+
+
+### Bug Fixes
+
+* checkout repo. before bumping lock ([#490](https://github.com/stoatchat/stoatchat/issues/490)) ([b2da2a8](https://github.com/stoatchat/stoatchat/commit/b2da2a858787853be43136fd526a0bd72baf78ef))
+* persist credentials for git repo ([#492](https://github.com/stoatchat/stoatchat/issues/492)) ([c674a9f](https://github.com/stoatchat/stoatchat/commit/c674a9fd4e0abbd51569870e4b38074d4a1de03c))
+
+## [0.9.3](https://github.com/stoatchat/stoatchat/compare/v0.9.2...v0.9.3) (2026-01-10)
+
+
+### Bug Fixes
+
+* pipeline fixes ([#487](https://github.com/stoatchat/stoatchat/issues/487)) ([aeeafeb](https://github.com/stoatchat/stoatchat/commit/aeeafebefc36a43a656cf797c9251ca50292733c))
+
+## [0.9.2](https://github.com/stoatchat/stoatchat/compare/v0.9.1...v0.9.2) (2026-01-10)
+
+
+### Bug Fixes
+
+* disable publish for services ([#485](https://github.com/stoatchat/stoatchat/issues/485)) ([d13609c](https://github.com/stoatchat/stoatchat/commit/d13609c37279d6a40445dcd99564e5c3dd03bac1))
+
+## [0.9.1](https://github.com/stoatchat/stoatchat/compare/v0.9.0...v0.9.1) (2026-01-10)
+
+
+### Bug Fixes
+
+* **ci:** pipeline fixes (marked as fix to force release) ([#483](https://github.com/stoatchat/stoatchat/issues/483)) ([303e52b](https://github.com/stoatchat/stoatchat/commit/303e52b476585eea81c33837f1b01506ce387684))
+
+## [0.9.0](https://github.com/stoatchat/stoatchat/compare/v0.8.8...v0.9.0) (2026-01-10)
+
+
+### Features
+
+* add id field to role ([#470](https://github.com/stoatchat/stoatchat/issues/470)) ([2afea56](https://github.com/stoatchat/stoatchat/commit/2afea56e56017f02de98e67316b4457568ad5b26))
+* add ratelimits to gifbox ([1542047](https://github.com/stoatchat/stoatchat/commit/154204742d21cbeff6e2577b00f50b495ea44631))
+* include groups and dms in fetch mutuals ([caa8607](https://github.com/stoatchat/stoatchat/commit/caa86074680d46223cebc20f41e9c91c41ec825d))
+* include member payload in ServerMemberJoin event ([480f210](https://github.com/stoatchat/stoatchat/commit/480f210ce85271e13d1dac58a5dae08de108579d))
+* initial work on tenor gif searching ([b0c977b](https://github.com/stoatchat/stoatchat/commit/b0c977b324b8144c1152589546eb8fec5954c3e7))
+* make message lexer use unowned string ([1561481](https://github.com/stoatchat/stoatchat/commit/1561481eb4cdc0f385fbf0a81e4950408050e11f))
+* ready payload field customisation ([db57706](https://github.com/stoatchat/stoatchat/commit/db577067948f13e830b5fb773034e9713a1abaff))
+* require auth for search ([b5cd5e3](https://github.com/stoatchat/stoatchat/commit/b5cd5e30ef7d5e56e8964fb7c543965fa6bf5a4a))
+* trending and categories routes ([5885e06](https://github.com/stoatchat/stoatchat/commit/5885e067a627b8fff1c8ce2bf9e852ff8cf3f07a))
+* voice chats v2 ([#414](https://github.com/stoatchat/stoatchat/issues/414)) ([d567155](https://github.com/stoatchat/stoatchat/commit/d567155f124e4da74115b1a8f810062f7c6559d9))
+
+
+### Bug Fixes
+
+* add license to revolt-parser ([5335124](https://github.com/stoatchat/stoatchat/commit/53351243064cac8d499dd74284be73928fa78a43))
+* allow for disabling default features ([65fbd36](https://github.com/stoatchat/stoatchat/commit/65fbd3662462aed1333b79e59155fa6377e83fcc))
+* apple music to use original url instead of metadata url ([bfe4018](https://github.com/stoatchat/stoatchat/commit/bfe4018e436a4075bae780dd4d35a9b58315e12f))
+* apply uname fix to january and autumn ([8f9015a](https://github.com/stoatchat/stoatchat/commit/8f9015a6ff181d208d9269ab8691bd417d39811a))
+* **ci:** publish images under stoatchat and remove docker hub ([d65c1a1](https://github.com/stoatchat/stoatchat/commit/d65c1a1ab3bdc7e5684b03f280af77d881661a3d))
+* correct miniz_oxide in lockfile ([#478](https://github.com/stoatchat/stoatchat/issues/478)) ([5d27a91](https://github.com/stoatchat/stoatchat/commit/5d27a91e901dd2ea3e860aeaed8468db6c5f3214))
+* correct shebang for try-tag-and-release ([050ba16](https://github.com/stoatchat/stoatchat/commit/050ba16d4adad5d0fb247867aa3e94e3d42bd12d))
+* correct string_cache in lockfile ([#479](https://github.com/stoatchat/stoatchat/issues/479)) ([0b178fc](https://github.com/stoatchat/stoatchat/commit/0b178fc791583064bf9ca94b1d39b42d021e1d79))
+* don't remove timeouts when a member leaves a server ([#409](https://github.com/stoatchat/stoatchat/issues/409)) ([e635bc2](https://github.com/stoatchat/stoatchat/commit/e635bc23ec857d648d5705e1a3875d7bc3402b0d))
+* don't update the same field while trying to remove it ([f4ee35f](https://github.com/stoatchat/stoatchat/commit/f4ee35fb093ca49f0a64ff4b17fd61587df28145)), closes [#392](https://github.com/stoatchat/stoatchat/issues/392)
+* github webhook incorrect payload and formatting ([#468](https://github.com/stoatchat/stoatchat/issues/468)) ([dc9c82a](https://github.com/stoatchat/stoatchat/commit/dc9c82aa4e9667ea6639256c65ac8de37a24d1f7))
+* implement Serialize to ClientMessage ([dea0f67](https://github.com/stoatchat/stoatchat/commit/dea0f675dde7a63c7a59b38d469f878b7a8a3af4))
+* newly created roles should be ranked the lowest ([947eb15](https://github.com/stoatchat/stoatchat/commit/947eb15771ed6785b3dcd16c354c03ded5e4cbe0))
+* permit empty `remove` array in edit requests ([6ad3da5](https://github.com/stoatchat/stoatchat/commit/6ad3da5f35f989a2e7d8e29718b98374248e76af))
+* preserve order of replies in message ([#447](https://github.com/stoatchat/stoatchat/issues/447)) ([657a3f0](https://github.com/stoatchat/stoatchat/commit/657a3f08e5d652814bbf0647e089ed9ebb139bbf))
+* prevent timing out members which have TimeoutMembers permission ([e36fc97](https://github.com/stoatchat/stoatchat/commit/e36fc9738bac0de4f3fcbccba521f1e3754f7ae7))
+* relax settings name regex ([3a34159](https://github.com/stoatchat/stoatchat/commit/3a3415915f0d0fdce1499d47a2b7fa097f5946ea))
+* remove authentication tag bytes from attachment download ([32e6600](https://github.com/stoatchat/stoatchat/commit/32e6600272b885c595c094f0bc69459250220dcb))
+* rename openapi operation ids ([6048587](https://github.com/stoatchat/stoatchat/commit/6048587d348fbca0dc3a9b47690c56df8fece576)), closes [#406](https://github.com/stoatchat/stoatchat/issues/406)
+* respond with 201 if no body in requests ([#465](https://github.com/stoatchat/stoatchat/issues/465)) ([24fedf8](https://github.com/stoatchat/stoatchat/commit/24fedf8c4d9cd3160bdec97aa451520f8beaa739))
+* swap to using reqwest for query building ([38dd4d1](https://github.com/stoatchat/stoatchat/commit/38dd4d10797b3e6e397fc219e818f379bdff19f2))
+* use `trust_cloudflare` config value instead of env var ([cc7a796](https://github.com/stoatchat/stoatchat/commit/cc7a7962a882e1627fcd0bc75858a017415e8cfc))
+* use our own result types instead of tenors types ([a92152d](https://github.com/stoatchat/stoatchat/commit/a92152d86da136997817e797c7af8e38731cdde8))

Cargo.toml

@@ -14,9 +14,37 @@ 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" }

Dockerfile

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

Dockerfile.useCurrentArch

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

README.md

@@ -1,15 +1,15 @@
 <div align="center">
 <h1>
-  Revolt Backend
+  Stoat Backend
   
-  [![Stars](https://img.shields.io/github/stars/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/stargazers)
-  [![Forks](https://img.shields.io/github/forks/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/network/members)
-  [![Pull Requests](https://img.shields.io/github/issues-pr/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/pulls)
-  [![Issues](https://img.shields.io/github/issues/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/issues)
-  [![Contributors](https://img.shields.io/github/contributors/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/graphs/contributors)
-  [![License](https://img.shields.io/github/license/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/blob/main/LICENSE)
+  [![Stars](https://img.shields.io/github/stars/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/stargazers)
+  [![Forks](https://img.shields.io/github/forks/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/network/members)
+  [![Pull Requests](https://img.shields.io/github/issues-pr/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/pulls)
+  [![Issues](https://img.shields.io/github/issues/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/issues)
+  [![Contributors](https://img.shields.io/github/contributors/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/graphs/contributors)
+  [![License](https://img.shields.io/github/license/stoatchat/stoatchat?style=flat-square&logoColor=white)](https://github.com/stoatchat/stoatchat/blob/main/LICENSE)
 </h1>
-The services and libraries that power the Revolt service.<br/>
+The services and libraries that power the Stoat service.<br/>
 <br/>
 
 | Crate              | Path                                               | Description                         |                                                                                                                                                                                                                                                                                                           |
@@ -21,9 +21,11 @@ The services and libraries that power the Revolt service.<br/>
 | `core/permissions` | [crates/core/permissions](crates/core/permissions) | Core: Permission Logic              | ![Crates.io Version](https://img.shields.io/crates/v/revolt-permissions) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-permissions) ![Crates.io Version](https://img.shields.io/crates/size/revolt-permissions) ![Crates.io License](https://img.shields.io/crates/l/revolt-permissions) |
 | `core/presence`    | [crates/core/presence](crates/core/presence)       | Core: User Presence                 | ![Crates.io Version](https://img.shields.io/crates/v/revolt-presence) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-presence) ![Crates.io Version](https://img.shields.io/crates/size/revolt-presence) ![Crates.io License](https://img.shields.io/crates/l/revolt-presence)             |
 | `core/result`      | [crates/core/result](crates/core/result)           | Core: Result and Error types        | ![Crates.io Version](https://img.shields.io/crates/v/revolt-result) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-result) ![Crates.io Version](https://img.shields.io/crates/size/revolt-result) ![Crates.io License](https://img.shields.io/crates/l/revolt-result)                     |
+| `core/coalesced`   | [crates/core/coalesced](crates/core/coalesced)     | Core: Coalescion service            | ![Crates.io Version](https://img.shields.io/crates/v/revolt-coalesced) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-coalesced) ![Crates.io Version](https://img.shields.io/crates/size/revolt-coalesced) ![Crates.io License](https://img.shields.io/crates/l/revolt-coalesced)         |
 | `delta`            | [crates/delta](crates/delta)                       | REST API server                     | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
 | `bonfire`          | [crates/bonfire](crates/bonfire)                   | WebSocket events server             | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
 | `services/january` | [crates/services/january](crates/services/january) | Proxy server                        | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
+| `services/gifbox`  | [crates/services/gifbox](crates/services/gifbox)   | Tenor proxy server                  | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
 | `services/autumn`  | [crates/services/autumn](crates/services/autumn)   | File server                         | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
 | `daemons/crond`    | [crates/daemons/crond](crates/daemons/crond)       | Timed data clean up daemon server   | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
 | `daemons/pushd`    | [crates/daemons/pushd](crates/daemons/pushd)       | Push notification daemon server     | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
@@ -35,22 +37,19 @@ The services and libraries that power the Revolt service.<br/>
 
 Rust 1.86.0 or higher.
 
-> [!CAUTION]
-> The events server has a significant performance regression between Rust 1.77.2 and 1.78.0 onwards, see [issue #341](https://github.com/revoltchat/backend/issues/341). This is currently solved by build time options but we are looking for a proper fix.
-
 ## Development Guide
 
-Before contributing, make yourself familiar with [our contribution guidelines](https://developers.revolt.chat/contrib.html) and the [technical documentation for this project](https://revoltchat.github.io/backend/).
+Before contributing, make yourself familiar with [our contribution guidelines](https://developers.stoat.chat/developing/contrib/) and the [technical documentation for this project](https://developers.stoat.chat/).
 
 Before getting started, you'll want to install:
 
-- Rust toolchain (rustup recommended)
+- mise
 - Docker
 - Git
 - mold (optional, faster compilation)
 
 > A **default.nix** is available for Nix users!
-> Just run `nix-shell` and continue.
+> Run `nix-shell` to activate mise.
 
 As a heads-up, the development environment uses the following ports:
 
@@ -66,13 +65,15 @@ As a heads-up, the development environment uses the following ports:
 | `crates/bonfire`          |     14703      |
 | `crates/services/autumn`  |     14704      |
 | `crates/services/january` |     14705      |
+| `crates/services/gifbox`  |     14706      |
 
 Now you can clone and build the project:
 
 ```bash
-git clone https://github.com/revoltchat/backend revolt-backend
-cd revolt-backend
-cargo build
+git clone https://github.com/stoatchat/stoatchat stoat-backend
+cd stoat-backend
+mise install
+mise build
 ```
 
 A default configuration `Revolt.toml` is present in this project that is suited for development.
@@ -130,9 +131,6 @@ 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
@@ -141,6 +139,8 @@ cargo run --bin revolt-bonfire
 cargo run --bin revolt-autumn
 # run the proxy server
 cargo run --bin revolt-january
+# run the tenor proxy
+cargo run --bin revolt-gifbox
 # run the push daemon (not usually needed in regular development)
 cargo run --bin revolt-pushd
 
@@ -156,16 +156,11 @@ 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/revoltchat/revite
-cd revite
-yarn
-yarn build:deps
-echo "VITE_API_URL=http://local.revolt.chat:14702" > .env.local
-yarn dev --port 14701
+git clone --recursive https://github.com/stoatchat/for-web stoat-web
+cd stoat-web
+# refer to stoat-web/README.md for startup, creating an account and loging in
 ```
 
-Then go to http://local.revolt.chat:14701 to create an account/login.
-
 When signing up, go to http://localhost:14080 to find confirmation/password reset emails.
 
 ## Deployment Guide
@@ -196,7 +191,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/revoltchat/backend/releases/new) to create a changelog.
+If you have bumped the crate versions, proceed to [GitHub releases](https://github.com/stoatchat/stoatchat/releases/new) to create a changelog.
 
 ## Testing
 
@@ -215,6 +210,6 @@ TEST_DB=MONGODB cargo nextest run
 
 ## License
 
-The Revolt backend is generally licensed under the [GNU Affero General Public License v3.0](https://github.com/revoltchat/backend/blob/master/LICENSE).
+The Stoat backend is generally licensed under the [GNU Affero General Public License v3.0](https://github.com/stoatchat/stoatchat/blob/main/LICENSE).
 
 **Individual crates may supply their own licenses!**

Revolt.toml

@@ -4,7 +4,7 @@
 [database]
 # MongoDB connection URL
 # Defaults to the container name specified in self-hosted
-mongodb = "mongodb://127.0.0.1:27017"
+mongodb = "mongodb://127.0.0.1:27017?directConnection=true&replicaSet=rs0"
 # 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/revoltchat/self-hosted/blob/master/Caddyfile
+# See https://github.com/stoatchat/self-hosted/blob/main/Caddyfile
 #
 # Remember to change these to https/wss where appropriate in production!
 app = "http://local.revolt.chat:14701"
@@ -26,6 +26,11 @@ january = "http://local.revolt.chat:14705"
 voso_legacy = ""
 voso_legacy_ws = ""
 
+# Public urls for livekit nodes
+# each entry here should have a corresponding entry under `api.livekit.nodes`
+[hosts.livekit]
+worldwide = "ws://local.revolt.chat:14706"
+
 [api]
 
 [api.smtp]
@@ -40,6 +45,18 @@ port = 14025
 use_tls = false
 use_starttls = false
 
+[api.livekit]
+
+# Config for livekit nodes
+# Make sure to change the secret when deploying
+# The key and secret should match the values livekit is using
+[api.livekit.nodes.worldwide]
+url = "http://livekit"
+lat = 0.0
+lon = 0.0
+key = "worldwide"
+secret = "ZjCofRlfm6GGtjlifmNpCDkcQbEIIVC0"
+
 [files.s3]
 # S3 protocol endpoint
 endpoint = "http://127.0.0.1:14009"

STYLE_GUIDE.md

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

compose.yml

@@ -8,10 +8,33 @@ 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:
@@ -40,7 +63,7 @@ services:
 
   # Rabbit
   rabbit:
-    image: rabbitmq:3-management
+    image: rabbitmq:4-management
     environment:
       RABBITMQ_DEFAULT_USER: rabbituser
       RABBITMQ_DEFAULT_PASS: rabbitpass
@@ -55,7 +78,7 @@ services:
 
   # Mock SMTP server
   maildev:
-    image: soulteary/maildev
+    image: maildev/maildev
     ports:
       - "14025:25"
       - "14080:8080"
@@ -64,3 +87,10 @@ services:
       MAILDEV_WEB_PORT: 8080
       MAILDEV_INCOMING_USER: smtp
       MAILDEV_INCOMING_PASS: smtp
+
+  livekit:
+    image: ghcr.io/stoatchat/livekit-server:v1.9.13
+    command: --config /etc/livekit.yml
+    network_mode: "host"
+    volumes:
+      - ./livekit.yml:/etc/livekit.yml

crates/bonfire/Cargo.toml

@@ -1,8 +1,9 @@
 [package]
 name = "revolt-bonfire"
-version = "0.8.8"
+version = "0.11.5"
 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
 
@@ -19,6 +20,7 @@ async-channel = "2.3.1"
 
 # parsing
 querystring = "1.1.0"
+regex = "1.11.1"
 
 # serde
 bincode = "1.3.3"
@@ -36,12 +38,12 @@ async-std = { version = "1.8.0", features = [
 ] }
 
 # core
-authifier = { version = "1.0.15" }
+authifier = { version = "1.0.16" }
 revolt-result = { path = "../core/result" }
 revolt-models = { path = "../core/models" }
 revolt-config = { path = "../core/config" }
-revolt-database = { path = "../core/database" }
-revolt-permissions = { version = "0.8.8", path = "../core/permissions" }
+revolt-database = { path = "../core/database", features = ["voice"] }
+revolt-permissions = { path = "../core/permissions" }
 revolt-presence = { path = "../core/presence", features = ["redis-is-patched"] }
 
 # redis

crates/bonfire/Dockerfile

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

crates/bonfire/src/config.rs

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

crates/bonfire/src/events/impl.rs

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

crates/bonfire/src/websocket.rs

@@ -218,7 +218,13 @@ async fn listener(
     kill_signal_r: async_channel::Receiver<()>,
     write: &Mutex<WsWriter>,
 ) {
-    let redis_config = RedisConfig::from_url(&REDIS_URI).unwrap();
+    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 subscriber = match report_internal_error!(
         fred::types::Builder::from_config(redis_config).build_subscriber_client()
     ) {
@@ -422,6 +428,8 @@ async fn worker(
     mut read: WsReader,
     write: &Mutex<WsWriter>,
 ) {
+    let revolt_config = revolt_config::config().await;
+
     loop {
         let t1 = read.try_next().fuse();
         let t2 = kill_signal_r.recv().fuse();
@@ -458,6 +466,10 @@ async fn worker(
 
                 match payload {
                     ClientMessage::BeginTyping { channel } => {
+                        if revolt_config.disable_events_dont_use {
+                            continue;
+                        }
+
                         if !subscribed.read().await.contains(&channel) {
                             continue;
                         }
@@ -470,6 +482,10 @@ async fn worker(
                         .await;
                     }
                     ClientMessage::EndTyping { channel } => {
+                        if revolt_config.disable_events_dont_use {
+                            continue;
+                        }
+
                         if !subscribed.read().await.contains(&channel) {
                             continue;
                         }

crates/core/coalesced/Cargo.toml

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

crates/core/coalesced/LICENSE

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

crates/core/coalesced/src/config.rs

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

crates/core/coalesced/src/error.rs

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

crates/core/coalesced/src/lib.rs

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

crates/core/coalesced/src/service.rs

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

crates/core/config/Cargo.toml

@@ -1,10 +1,11 @@
 [package]
 name = "revolt-config"
-version = "0.8.8"
+version = "0.11.5"
 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
 
@@ -37,4 +38,4 @@ sentry = { version = "0.31.5", optional = true }
 sentry-anyhow = { version = "0.38.1", optional = true }
 
 # Core
-revolt-result = { version = "0.8.8", path = "../result", optional = true }
+revolt-result = { version = "0.11.5", path = "../result", optional = true }

crates/core/config/Revolt.test.toml

@@ -1,5 +1,5 @@
 [database]
-mongodb = "mongodb://localhost"
+mongodb = "mongodb://localhost?directConnection=true&replicaSet=rs0"
 redis = "redis://localhost/"
 
 [rabbit]

crates/core/config/Revolt.toml

@@ -1,9 +1,10 @@
 production = false
+disable_events_dont_use = false
 
 [database]
 # MongoDB connection URL
 # Defaults to the container name specified in self-hosted
-mongodb = "mongodb://database"
+mongodb = "mongodb://database?directConnection=true&replicaSet=rs0"
 # Redis connection URL
 # Defaults to the container name specified in self-hosted
 redis = "redis://redis/"
@@ -11,7 +12,7 @@ redis = "redis://redis/"
 [hosts]
 # Web locations of various services
 # Defaults assume all services are reverse-proxied
-# See https://github.com/revoltchat/self-hosted/blob/master/Caddyfile
+# See https://github.com/stoatchat/self-hosted/blob/main/Caddyfile
 #
 # Remember to change these to https/wss where appropriate in production!
 app = "http://local.revolt.chat"
@@ -22,6 +23,8 @@ january = "http://local.revolt.chat/january"
 voso_legacy = ""
 voso_legacy_ws = ""
 
+[hosts.livekit]
+
 [rabbit]
 host = "rabbit"
 port = 5672
@@ -32,7 +35,7 @@ password = "rabbitpass"
 
 [api.registration]
 # Whether an invite should be required for registration
-# See https://github.com/revoltchat/self-hosted#making-your-instance-invite-only
+# See https://github.com/stoatchat/self-hosted#making-your-instance-invite-only
 invite_only = false
 
 [api.smtp]
@@ -56,6 +59,8 @@ voso_legacy_token = ""
 trust_cloudflare = false
 # easypwned endpoint
 easypwned = ""
+# Tenor API Key
+tenor_key = ""
 
 [api.security.captcha]
 # hCaptcha configuration
@@ -66,8 +71,13 @@ hcaptcha_sitekey = ""
 # Maximum concurrent connections (to proxy server)
 max_concurrent_connections = 50
 
-[api.users]
+[api.livekit]
+# How long to ring devices for when calling in dms/groups, in seconds
+call_ring_duration = 30
 
+[api.livekit.nodes]
+
+[api.users]
 
 [pushd]
 # this changes the names of the queues to not overlap 
@@ -79,12 +89,18 @@ production = true
 # Increasing this will resolve mentions faster, but will consume more memory while resolving.
 mass_mention_chunk_size = 200
 
+# How long pushd will cache resolved names for rendered message notifications.
+# Increasing this will result in lower database usage, but may result in a situation where a user/channel/role name changes 
+# and the notifications still resolve to the old name.
+render_cache_time = 60
+
 # none of these should need changing
 exchange = "revolt.notifications"
 message_queue = "notifications.origin.message"
 mass_mention_queue = "notifications.origin.mass_mention" # handles messages that contain role or everyone mentions
 fr_accepted_queue = "notifications.ingest.fr_accepted"   # friend request accepted
 fr_received_queue = "notifications.ingest.fr_received"   # friend request received
+dm_call_queue = "notifications.ingest.dm_call"   # direct message voice call
 generic_queue = "notifications.ingest.generic"           # generic messages (title + body)
 ack_queue = "notifications.process.ack"                  # updates badges for apple devices
 
@@ -210,6 +226,10 @@ new_user_hours = 72
 # (should be greater than any one file upload limit)
 body_limit_size = 20_000_000
 
+# If any userids are entered here, only those users will be able to create servers.
+# Leave empty to allow all users to create servers
+restrict_server_creation = []
+
 [features.limits.new_user]
 # Limits imposed on new users
 
@@ -228,6 +248,18 @@ message_attachments = 5
 # Maximum number of servers the user can create/join
 servers = 50
 
+# Maximum audio frequency (Hz) in voice calls
+voice_quality = 16000
+
+# Whether the user can use video streams in voice calls
+video = true
+
+# Maximum resolution (width, height) of video streams in voice calls
+video_resolution = [1080, 720]
+
+# Minimum and maximum aspect ratio of video streams in voice calls
+video_aspect_ratio = [0.3, 2.5]
+
 [features.limits.new_user.file_upload_size_limit]
 # Maximum file size limits (in bytes)
 attachments = 20_000_000
@@ -255,6 +287,18 @@ message_attachments = 5
 # Maximum number of servers the user can create/join
 servers = 100
 
+# Maximum audio frequency (Hz) in voice calls
+voice_quality = 16000
+
+# Whether the user can use video streams in voice calls
+video = true
+
+# Maximum resolution (width, height) of video streams in voice calls
+video_resolution = [1280, 720]
+
+# Minimum and maximum aspect ratio of video streams in voice calls
+video_aspect_ratio = [0.3, 2.5]
+
 [features.limits.default.file_upload_size_limit]
 # Maximum file size limits (in bytes)
 attachments = 20_000_000
@@ -273,7 +317,9 @@ process_message_delay_limit = 5
 # Configuration for Sentry error reporting
 api = ""
 events = ""
+voice_ingress = ""
 files = ""
 proxy = ""
 pushd = ""
 crond = ""
+gifbox = ""

crates/core/config/src/lib.rs

@@ -1,7 +1,7 @@
-use std::collections::HashMap;
+use std::{collections::HashMap, path::Path};
 
 use cached::proc_macro::cached;
-use config::{Config, File, FileFormat};
+use config::{Config, Environment, File, FileFormat};
 use futures_locks::RwLock;
 use once_cell::sync::Lazy;
 use serde::Deserialize;
@@ -94,12 +94,23 @@ static CONFIG_BUILDER: Lazy<RwLock<Config>> = Lazy::new(|| {
             }
         }
 
-        for path in CONFIG_SEARCH_PATHS {
-            if std::path::Path::new(path).exists() {
-                builder = builder.add_source(File::new(path, FileFormat::Toml));
+        let cwd = std::env::current_dir().unwrap();
+        let mut cwd: Option<&Path> = Some(&cwd);
+
+        while let Some(path) = cwd {
+            for config_path in CONFIG_SEARCH_PATHS {
+                let config_path = path.join(config_path);
+                if config_path.exists() {
+                    builder = builder
+                        .add_source(File::new(config_path.to_str().unwrap(), FileFormat::Toml));
+                }
             }
+
+            cwd = path.parent();
         }
 
+        builder = builder.add_source(Environment::with_prefix("REVOLT").separator("__"));
+
         builder.build().unwrap()
     })
 });
@@ -108,6 +119,7 @@ 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)]
@@ -125,8 +137,7 @@ pub struct Hosts {
     pub events: String,
     pub autumn: String,
     pub january: String,
-    pub voso_legacy: String,
-    pub voso_legacy_ws: String,
+    pub livekit: HashMap<String, String>,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -190,6 +201,7 @@ pub struct ApiSecurity {
     pub captcha: ApiSecurityCaptcha,
     pub trust_cloudflare: bool,
     pub easypwned: String,
+    pub tenor_key: String,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -197,6 +209,25 @@ 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>,
@@ -208,6 +239,7 @@ pub struct Api {
     pub smtp: ApiSmtp,
     pub security: ApiSecurity,
     pub workers: ApiWorkers,
+    pub livekit: ApiLiveKit,
     pub users: ApiUsers,
 }
 
@@ -216,10 +248,12 @@ pub struct Pushd {
     pub production: bool,
     pub exchange: String,
     pub mass_mention_chunk_size: usize,
+    pub render_cache_time: usize,
 
     // Queues
     pub message_queue: String,
     pub mass_mention_queue: String,
+    pub dm_call_queue: String,
     pub fr_accepted_queue: String,
     pub fr_received_queue: String,
     pub generic_queue: String,
@@ -250,6 +284,10 @@ impl Pushd {
         self.get_routing_key(self.mass_mention_queue.clone())
     }
 
+    pub fn get_dm_call_routing_key(&self) -> String {
+        self.get_routing_key(self.dm_call_queue.clone())
+    }
+
     pub fn get_fr_accepted_routing_key(&self) -> String {
         self.get_routing_key(self.fr_accepted_queue.clone())
     }
@@ -307,6 +345,8 @@ pub struct GlobalLimits {
     pub new_user_hours: usize,
 
     pub body_limit_size: usize,
+
+    pub restrict_server_creation: Vec<String>,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -317,6 +357,10 @@ pub struct FeaturesLimits {
     pub message_length: usize,
     pub message_attachments: usize,
     pub servers: usize,
+    pub voice_quality: u32,
+    pub video: bool,
+    pub video_resolution: [u32; 2],
+    pub video_aspect_ratio: [f32; 2],
 
     pub file_upload_size_limit: HashMap<String, usize>,
 }
@@ -361,10 +405,12 @@ pub struct Features {
 pub struct Sentry {
     pub api: String,
     pub events: String,
+    pub voice_ingress: String,
     pub files: String,
     pub proxy: String,
     pub pushd: String,
     pub crond: String,
+    pub gifbox: String,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -378,6 +424,7 @@ pub struct Settings {
     pub features: Features,
     pub sentry: Sentry,
     pub production: bool,
+    pub disable_events_dont_use: bool,
 }
 
 impl Settings {
@@ -408,12 +455,14 @@ pub async fn config() -> Settings {
     let mut config = read().await.try_deserialize::<Settings>().unwrap();
 
     // inject REDIS_URI for redis-kiss library
-    if std::env::var("REDIS_URL").is_err() {
+    if std::env::var("REDIS_URI").is_err() {
         std::env::set_var("REDIS_URI", config.database.redis.clone());
     }
 
     // auto-detect production nodes
-    if config.hosts.api.contains("https") && config.hosts.api.contains("revolt.chat") {
+    if config.hosts.api.contains("https")
+        && (config.hosts.api.contains("revolt.chat") || config.hosts.api.contains("stoat.chat"))
+    {
         config.production = true;
     }
 

crates/core/database/Cargo.toml

@@ -1,10 +1,11 @@
 [package]
 name = "revolt-database"
-version = "0.8.8"
+version = "0.11.5"
 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
 
@@ -15,28 +16,35 @@ 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"]
+rocket-impl = [
+    "rocket",
+    "schemars",
+    "revolt_okapi",
+    "revolt_rocket_okapi",
+    "authifier/rocket_impl",
+]
+axum-impl = ["axum", "revolt-result/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.8.8", path = "../config", features = [
+revolt-config = { version = "0.11.5", path = "../config", features = [
     "report-macros",
 ] }
-revolt-result = { version = "0.8.8", path = "../result" }
-revolt-models = { version = "0.8.8", path = "../models", features = [
+revolt-result = { version = "0.11.5", path = "../result" }
+revolt-models = { version = "0.11.5", path = "../models", features = [
     "validator",
 ] }
-revolt-presence = { version = "0.8.8", path = "../presence" }
-revolt-permissions = { version = "0.8.8", path = "../permissions", features = [
+revolt-presence = { version = "0.11.5", path = "../presence" }
+revolt-permissions = { version = "0.11.5", path = "../permissions", features = [
     "serde",
     "bson",
 ] }
-revolt-parser = { version = "0.8.8", path = "../parser" }
+revolt-parser = { version = "0.11.5", path = "../parser" }
 
 # Utility
 log = "0.4"
@@ -92,7 +100,12 @@ revolt_okapi = { version = "0.9.1", optional = true }
 revolt_rocket_okapi = { version = "0.10.0", optional = true }
 
 # Authifier
-authifier = { version = "1.0.15" }
+authifier = { version = "1.0.16" }
 
 # 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 }

crates/core/database/fixtures/server_with_roles.json

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

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

@@ -2,7 +2,8 @@ use std::collections::HashSet;
 
 use crate::events::rabbit::*;
 use crate::User;
-use amqprs::channel::BasicPublishArguments;
+use amqprs::channel::{BasicPublishArguments, ExchangeDeclareArguments};
+use amqprs::connection::OpenConnectionArguments;
 use amqprs::{channel::Channel, connection::Connection, error::Error as AMQPError};
 use amqprs::{BasicProperties, FieldTable};
 use revolt_models::v0::PushNotification;
@@ -25,6 +26,35 @@ 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,
@@ -240,4 +270,50 @@ 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
+    }
 }

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

@@ -10,6 +10,7 @@ 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;
@@ -35,7 +36,7 @@ pub enum DatabaseInfo {
 }
 
 /// Database
-#[derive(Clone)]
+#[derive(Clone, Debug)]
 pub enum Database {
     /// Mock database
     Reference(ReferenceDb),
@@ -69,7 +70,7 @@ impl DatabaseInfo {
                     .await;
 
                     #[cfg(not(feature = "mongodb"))]
-                    return Err("MongoDB not enabled.".to_string())
+                    return Err("MongoDB not enabled.".to_string());
                 } else {
                     DatabaseInfo::Reference.connect().await
                 }
@@ -90,7 +91,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"),
                 }
@@ -137,29 +138,33 @@ impl Database {
                                 .api
                                 .smtp
                                 .reply_to
-                                .unwrap_or("support@revolt.chat".into()),
+                                .unwrap_or("support@stoat.chat".into()),
                         ),
                         port: config.api.smtp.port,
                         use_tls: config.api.smtp.use_tls,
                         use_starttls: config.api.smtp.use_starttls,
                     },
-                    expiry: Default::default(),
+                    expiry: EmailExpiryConfig {
+                        expire_verification: 3600 * 24 * 7,
+                        expire_password_reset: 3600 * 24,
+                        expire_account_deletion: 3600 * 24,
+                    },
                     templates: if config.production {
                         Templates {
                             verify: Template {
-                                title: "Verify your Revolt account.".into(),
+                                title: "Verify your Stoat account.".into(),
                                 text: include_str!("../../templates/verify.txt").into(),
                                 url: format!("{}/login/verify/", config.hosts.app),
                                 html: Some(include_str!("../../templates/verify.html").into()),
                             },
                             reset: Template {
-                                title: "Reset your Revolt password.".into(),
+                                title: "Reset your Stoat password.".into(),
                                 text: include_str!("../../templates/reset.txt").into(),
                                 url: format!("{}/login/reset/", config.hosts.app),
                                 html: Some(include_str!("../../templates/reset.html").into()),
                             },
                             reset_existing: Template {
-                                title: "You already have a Revolt account, reset your password."
+                                title: "You already have a Stoat account, reset your password."
                                     .into(),
                                 text: include_str!("../../templates/reset-existing.txt").into(),
                                 url: format!("{}/login/reset/", config.hosts.app),

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

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

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

@@ -10,7 +10,7 @@ use crate::{
 
 database_derived!(
     /// Reference implementation
-    #[derive(Default)]
+    #[derive(Default, Debug)]
     pub struct ReferenceDb {
         pub bots: Arc<Mutex<HashMap<String, Bot>>>,
         pub channels: Arc<Mutex<HashMap<String, Channel>>>,

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

@@ -3,10 +3,7 @@ use revolt_result::Error;
 use serde::{Deserialize, Serialize};
 
 use revolt_models::v0::{
-    AppendMessage, Channel, ChannelUnread, Emoji, FieldsChannel, FieldsMember, FieldsMessage,
-    FieldsRole, FieldsServer, FieldsUser, FieldsWebhook, Member, MemberCompositeKey, Message,
-    PartialChannel, PartialMember, PartialMessage, PartialRole, PartialServer, PartialUser,
-    PartialWebhook, PolicyChange, RemovalIntention, Report, Server, User, UserSettings, Webhook,
+    AppendMessage, Channel, 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
 };
 
 use crate::Database;
@@ -20,16 +17,33 @@ pub enum Ping {
 }
 
 /// Fields provided in Ready payload
-#[derive(PartialEq)]
-pub enum ReadyPayloadFields {
-    Users,
-    Servers,
-    Channels,
-    Members,
-    Emoji,
+#[derive(PartialEq, Debug, Clone, Deserialize)]
+pub struct ReadyPayloadFields {
+    pub users: bool,
+    pub servers: bool,
+    pub channels: bool,
+    pub members: bool,
+    pub emojis: bool,
+    pub voice_states: bool,
+    pub user_settings: Vec<String>,
+    pub channel_unreads: bool,
+    pub policy_changes: bool,
+}
 
-    UserSettings(Vec<String>),
-    ChannelUnreads,
+impl Default for ReadyPayloadFields {
+    fn default() -> Self {
+        Self {
+            users: true,
+            servers: true,
+            channels: true,
+            members: true,
+            emojis: true,
+            voice_states: true,
+            user_settings: Vec::new(),
+            channel_unreads: false,
+            policy_changes: true,
+        }
+    }
 }
 
 /// Protocol Events
@@ -57,13 +71,16 @@ pub enum EventV1 {
         members: Option<Vec<Member>>,
         #[serde(skip_serializing_if = "Option::is_none")]
         emojis: Option<Vec<Emoji>>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        voice_states: Option<Vec<ChannelVoiceState>>,
 
         #[serde(skip_serializing_if = "Option::is_none")]
         user_settings: Option<UserSettings>,
         #[serde(skip_serializing_if = "Option::is_none")]
         channel_unreads: Option<Vec<ChannelUnread>>,
 
-        policy_changes: Vec<PolicyChange>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        policy_changes: Option<Vec<PolicyChange>>,
     },
 
     /// Ping response
@@ -122,6 +139,7 @@ pub enum EventV1 {
         server: Server,
         channels: Vec<Channel>,
         emojis: Vec<Emoji>,
+        voice_states: Vec<ChannelVoiceState>
     },
 
     /// Update existing server
@@ -254,6 +272,33 @@ 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 {

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

@@ -37,6 +37,20 @@ pub struct GenericPayload {
     pub user: User,
 }
 
+#[derive(Serialize, Deserialize, Clone)]
+pub struct DmCallPayload {
+    pub initiator_id: String,
+    pub channel_id: String,
+    pub started_at: Option<String>,
+    pub ended: bool,
+}
+
+#[derive(Serialize, Deserialize, Clone)]
+pub struct InternalDmCallPayload {
+    pub payload: DmCallPayload,
+    pub recipients: Option<Vec<String>>,
+}
+
 #[derive(Serialize, Deserialize)]
 #[serde(tag = "type", content = "data")]
 #[allow(clippy::large_enum_variant)]
@@ -46,6 +60,7 @@ pub enum PayloadKind {
     FRReceived(FRReceivedPayload),
     BadgeUpdate(usize),
     Generic(GenericPayload),
+    DmCallStartEnd(DmCallPayload),
 }
 
 #[derive(Serialize, Deserialize)]

crates/core/database/src/lib.rs

@@ -112,6 +112,10 @@ pub mod tasks;
 mod amqp;
 pub use amqp::amqp::AMQP;
 
+#[cfg(feature = "voice")]
+pub mod voice;
+
+
 /// Utility function to check if a boolean value is false
 pub fn if_false(t: &bool) -> bool {
     !t

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

@@ -9,14 +9,13 @@ use crate::{
         bson::{doc, from_bson, from_document, to_document, Bson, DateTime, Document},
         options::FindOptions,
     },
-    AbstractChannels, AbstractServers, Channel, Invite, MongoDb, User, DISCRIMINATOR_SEARCH_SPACE,
+    AbstractServers, Invite, MongoDb, User, DISCRIMINATOR_SEARCH_SPACE,
 };
 use bson::{oid::ObjectId, to_bson};
 use futures::StreamExt;
 use iso8601_timestamp::Timestamp;
 use rand::seq::SliceRandom;
-use revolt_permissions::DEFAULT_WEBHOOK_PERMISSIONS;
-use revolt_result::{Error, ErrorType};
+use revolt_permissions::{ChannelPermission, DEFAULT_WEBHOOK_PERMISSIONS};
 use serde::{Deserialize, Serialize};
 use unicode_segmentation::UnicodeSegmentation;
 
@@ -26,7 +25,7 @@ struct MigrationInfo {
     revision: i32,
 }
 
-pub const LATEST_REVISION: i32 = 42; // MUST BE +1 to last migration
+pub const LATEST_REVISION: i32 = 50; // MUST BE +1 to last migration
 
 pub async fn migrate_database(db: &MongoDb) {
     let migrations = db.col::<Document>("migrations");
@@ -914,6 +913,7 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
     }
 
     if revision <= 26 {
+        // Need to migrate fields on attachments, change `user_id`, `object_id`, etc to `parent`.
         info!("Running migration [revision 26 / 15-05-2024]: fix invites being incorrectly serialized with wrong enum tagging.");
 
         auto_derived!(
@@ -1080,6 +1080,14 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
             channel_id: String,
         }
 
+        #[allow(clippy::enum_variant_names)]
+        #[derive(serde::Serialize, serde::Deserialize)]
+        enum Channel {
+            Group { owner: String },
+            TextChannel { server: String },
+            VoiceChannel { server: String }
+        }
+
         let webhooks = db
             .db()
             .collection::<WebhookShell>("channel_webhooks")
@@ -1091,8 +1099,8 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
             .await;
 
         for webhook in webhooks {
-            match db.fetch_channel(&webhook.channel_id).await {
-                Ok(channel) => {
+            match db.col::<Channel>("channels").find_one(doc! { "_id": &webhook.channel_id }).await.unwrap() {
+                Some(channel) => {
                     let creator_id = match channel {
                         Channel::Group { owner, .. } => owner,
                         Channel::TextChannel { server, .. }
@@ -1100,7 +1108,6 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
                             let server = db.fetch_server(&server).await.expect("server");
                             server.owner
                         }
-                        _ => unreachable!("not server or group channel!"),
                     };
 
                     db.db()
@@ -1118,17 +1125,13 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
                         .await
                         .expect("update webhook");
                 }
-                Err(Error {
-                    error_type: ErrorType::NotFound,
-                    ..
-                }) => {
+                None => {
                     db.db()
                         .collection::<WebhookShell>("channel_webhooks")
                         .delete_one(doc! { "_id": webhook._id })
                         .await
                         .expect("failed to delete invalid webhook");
                 }
-                Err(err) => panic!("{err:?}"),
             }
         }
     }
@@ -1169,9 +1172,9 @@ pub async fn run_migrations(db: &MongoDb, revision: i32) -> i32 {
             .expect("failed to update users");
     }
 
-    if revision <= 41 {
+    if revision <= 43 {
         info!(
-            "Running migration [revision 41 / 05-06-2025]: convert role ranks to uniform numbers."
+            "Running migration [revision 43 / 05-06-2025]: convert role ranks to uniform numbers."
         );
 
         #[derive(Serialize, Deserialize, Clone)]
@@ -1226,6 +1229,83 @@ 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)
 }

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

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

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

@@ -1,4 +1,5 @@
-use std::collections::HashMap;
+#![allow(deprecated)]
+use std::{borrow::Cow, collections::HashMap};
 
 use revolt_config::config;
 use revolt_models::v0::{self, MessageAuthor};
@@ -8,8 +9,7 @@ use serde::{Deserialize, Serialize};
 use ulid::Ulid;
 
 use crate::{
-    events::client::EventV1, Database, File, PartialServer,
-    Server, SystemMessage, User, AMQP,
+    events::client::EventV1, Database, File, PartialServer, Server, SystemMessage, User, AMQP,
 };
 
 #[cfg(feature = "mongodb")]
@@ -106,38 +106,22 @@ auto_derived!(
             /// Whether this channel is marked as not safe for work
             #[serde(skip_serializing_if = "crate::if_false", default)]
             nsfw: bool,
+
+            /// Voice Information for when this channel is also a voice channel
+            #[serde(skip_serializing_if = "Option::is_none")]
+            voice: Option<VoiceInformation>,
+
+            /// The channel's slowmode delay in seconds
+            #[serde(skip_serializing_if = "Option::is_none")]
+            slowmode: Option<u64>,
         },
-        /// Voice channel belonging to a server
-        VoiceChannel {
-            /// Unique Id
-            #[serde(rename = "_id")]
-            id: String,
-            /// Id of the server this channel belongs to
-            server: String,
+    }
 
-            /// Display name of the channel
-            name: String,
-            #[serde(skip_serializing_if = "Option::is_none")]
-            /// Channel description
-            description: Option<String>,
-            /// Custom icon attachment
-            #[serde(skip_serializing_if = "Option::is_none")]
-            icon: Option<File>,
-
-            /// Default permissions assigned to users in this channel
-            #[serde(skip_serializing_if = "Option::is_none")]
-            default_permissions: Option<OverrideField>,
-            /// Permissions assigned based on role to this channel
-            #[serde(
-                default = "HashMap::<String, OverrideField>::new",
-                skip_serializing_if = "HashMap::<String, OverrideField>::is_empty"
-            )]
-            role_permissions: HashMap<String, OverrideField>,
-
-            /// Whether this channel is marked as not safe for work
-            #[serde(skip_serializing_if = "crate::if_false", default)]
-            nsfw: bool,
-        },
+    #[derive(Default)]
+    pub struct VoiceInformation {
+        /// Maximium amount of users allowed in the voice channel at once
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub max_users: Option<usize>,
     }
 );
 
@@ -164,6 +148,10 @@ auto_derived!(
         pub default_permissions: Option<OverrideField>,
         #[serde(skip_serializing_if = "Option::is_none")]
         pub last_message_id: Option<String>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub voice: Option<VoiceInformation>,
+        #[serde(skip_serializing_if = "Option::is_none")]
+        pub slowmode: Option<u64>,
     }
 
     /// Optional fields on channel object
@@ -171,6 +159,7 @@ auto_derived!(
         Description,
         Icon,
         DefaultPermissions,
+        Voice,
     }
 );
 
@@ -222,16 +211,21 @@ impl Channel {
                 default_permissions: None,
                 role_permissions: HashMap::new(),
                 nsfw: data.nsfw.unwrap_or(false),
+                voice: data.voice.map(|voice| voice.into()),
+                slowmode: None
             },
-            v0::LegacyServerChannelType::Voice => Channel::VoiceChannel {
+            v0::LegacyServerChannelType::Voice => Channel::TextChannel {
                 id: id.clone(),
                 server: server.id.to_owned(),
                 name: data.name,
                 description: data.description,
                 icon: None,
+                last_message_id: None,
                 default_permissions: None,
                 role_permissions: HashMap::new(),
                 nsfw: data.nsfw.unwrap_or(false),
+                voice: Some(data.voice.unwrap_or_default().into()),
+                slowmode: None
             },
         };
 
@@ -432,8 +426,28 @@ impl Channel {
             Channel::DirectMessage { id, .. }
             | Channel::Group { id, .. }
             | Channel::SavedMessages { id, .. }
-            | Channel::TextChannel { id, .. }
-            | Channel::VoiceChannel { id, .. } => id,
+            | Channel::TextChannel { id, .. } => id,
+        }
+    }
+
+    /// Clone this channel's server id
+    pub fn server(&self) -> Option<&str> {
+        match self {
+            Channel::TextChannel { server, .. } => Some(server),
+            _ => None,
+        }
+    }
+
+    /// Gets this channel's voice information
+    pub fn voice(&self) -> Option<Cow<VoiceInformation>> {
+        match self {
+            Self::DirectMessage { .. } | Self::Group { .. } => {
+                Some(Cow::Owned(VoiceInformation::default()))
+            }
+            Self::TextChannel {
+                voice: Some(voice), ..
+            } => Some(Cow::Borrowed(voice)),
+            _ => None,
         }
     }
 
@@ -450,12 +464,6 @@ impl Channel {
                 server,
                 role_permissions,
                 ..
-            }
-            | Channel::VoiceChannel {
-                id,
-                server,
-                role_permissions,
-                ..
             } => {
                 db.set_channel_role_permission(id, role_id, permissions)
                     .await?;
@@ -502,7 +510,7 @@ impl Channel {
             clear: remove.into_iter().map(|v| v.into()).collect(),
         }
         .p(match self {
-            Self::TextChannel { server, .. } | Self::VoiceChannel { server, .. } => server.clone(),
+            Self::TextChannel { server, .. } => server.clone(),
             _ => id,
         })
         .await;
@@ -514,17 +522,13 @@ impl Channel {
     pub fn remove_field(&mut self, field: &FieldsChannel) {
         match field {
             FieldsChannel::Description => match self {
-                Self::Group { description, .. }
-                | Self::TextChannel { description, .. }
-                | Self::VoiceChannel { description, .. } => {
+                Self::Group { description, .. } | Self::TextChannel { description, .. } => {
                     description.take();
                 }
                 _ => {}
             },
             FieldsChannel::Icon => match self {
-                Self::Group { icon, .. }
-                | Self::TextChannel { icon, .. }
-                | Self::VoiceChannel { icon, .. } => {
+                Self::Group { icon, .. } | Self::TextChannel { icon, .. } => {
                     icon.take();
                 }
                 _ => {}
@@ -533,15 +537,17 @@ impl Channel {
                 Self::TextChannel {
                     default_permissions,
                     ..
-                }
-                | Self::VoiceChannel {
-                    default_permissions,
-                    ..
                 } => {
                     default_permissions.take();
                 }
                 _ => {}
             },
+            FieldsChannel::Voice => match self {
+                Self::TextChannel { voice, .. } => {
+                    voice.take();
+                }
+                _ => {}
+            },
         }
     }
 
@@ -553,6 +559,7 @@ impl Channel {
     }
 
     /// Apply partial channel to channel
+    #[allow(deprecated)]
     pub fn apply_options(&mut self, partial: PartialChannel) {
         match self {
             Self::SavedMessages { .. } => {}
@@ -601,15 +608,7 @@ impl Channel {
                 nsfw,
                 default_permissions,
                 role_permissions,
-                ..
-            }
-            | Self::VoiceChannel {
-                name,
-                description,
-                icon,
-                nsfw,
-                default_permissions,
-                role_permissions,
+                voice,
                 ..
             } => {
                 if let Some(v) = partial.name {
@@ -635,6 +634,10 @@ impl Channel {
                 if let Some(v) = partial.default_permissions {
                     default_permissions.replace(v);
                 }
+
+                if let Some(v) = partial.voice {
+                    voice.replace(v);
+                }
             }
         }
     }
@@ -777,6 +780,7 @@ impl IntoDocumentPath for FieldsChannel {
             FieldsChannel::Description => "description",
             FieldsChannel::Icon => "icon",
             FieldsChannel::DefaultPermissions => "default_permissions",
+            FieldsChannel::Voice => "voice",
         })
     }
 }

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

@@ -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::VoiceChannel { server, .. } => {
+            Channel::TextChannel { server, .. } => {
                 Some(server)
             }
             _ => None,

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

@@ -94,9 +94,6 @@ 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);

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

@@ -45,7 +45,9 @@ auto_derived!(
         Image {
             width: isize,
             height: isize,
-            // animated: bool // TODO: https://docs.rs/image/latest/image/trait.AnimationDecoder.html for APNG support
+            thumbhash: Option<Vec<u8>>,
+            #[serde(default)]
+            animated: bool,
         },
         /// File is a video with specific dimensions
         Video { width: isize, height: isize },

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

@@ -1,5 +1,3 @@
-use std::{collections::HashSet, hash::RandomState};
-
 use indexmap::{IndexMap, IndexSet};
 use iso8601_timestamp::Timestamp;
 use revolt_config::{config, FeaturesLimits};
@@ -9,6 +7,8 @@ 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,6 +114,11 @@ 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
@@ -326,9 +331,7 @@ impl Message {
         }
 
         let server_id = match channel {
-            Channel::TextChannel { ref server, .. } | Channel::VoiceChannel { ref server, .. } => {
-                Some(server.clone())
-            }
+            Channel::TextChannel { ref server, .. } => Some(server.clone()),
             _ => None,
         };
 
@@ -385,6 +388,7 @@ 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() {
@@ -440,7 +444,8 @@ impl Message {
         }
 
         // Verify replies are valid.
-        let mut replies = HashSet::new();
+        let mut replies = Vec::new();
+
         if let Some(entries) = data.replies {
             if entries.len() > config.features.limits.global.message_replies {
                 return Err(create_error!(TooManyReplies {
@@ -448,6 +453,8 @@ impl Message {
                 }));
             }
 
+            replies.reserve(entries.len());
+
             for ReplyIntent {
                 id,
                 mention,
@@ -461,7 +468,12 @@ impl Message {
                             user_mentions.insert(message.author.to_owned());
                         }
 
-                        replies.insert(message.id);
+                        // This is O(n^2), but this is faster than a HashSet
+                        // when n < 20; as long as the message_replies limit
+                        // is reasonable, this will be fast.
+                        if !replies.contains(&message.id) {
+                            replies.push(message.id);
+                        }
                     }
                     // If the referenced message doesn't exist and fail_if_not_exists
                     // is set to false, send the message without the reply.
@@ -478,6 +490,7 @@ 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, .. } => {
@@ -485,8 +498,7 @@ impl Message {
                     user_mentions.retain(|m| recipients_hash.contains(m));
                     role_mentions.clear();
                 }
-                Channel::TextChannel { ref server, .. }
-                | Channel::VoiceChannel { ref server, .. } => {
+                Channel::TextChannel { ref server, .. } => {
                     let mentions_vec = Vec::from_iter(user_mentions.iter().cloned());
 
                     let valid_members = db.fetch_members(server.as_str(), &mentions_vec[..]).await;
@@ -534,9 +546,7 @@ impl Message {
         }
 
         if !replies.is_empty() {
-            message
-                .replies
-                .replace(replies.into_iter().collect::<Vec<String>>());
+            message.replies.replace(replies);
         }
 
         // Calculate final message flags
@@ -678,9 +688,13 @@ impl Message {
         )
         .await?;
 
+        let is_dm_or_group = matches!(
+            channel,
+            Channel::DirectMessage { .. } | Channel::Group { .. }
+        );
 
         if !self.has_suppressed_notifications()
-            && (self.mentions.is_some() || self.contains_mass_push_mention())
+            && (is_dm_or_group || self.mentions.is_some() || self.contains_mass_push_mention())
         {
             // send Push notifications
             #[cfg(feature = "tasks")]
@@ -794,7 +808,7 @@ impl Message {
         query: MessageQuery,
         perspective: &User,
         include_users: Option<bool>,
-        server_id: Option<String>,
+        server_id: Option<&str>,
     ) -> Result<BulkMessageResponse> {
         let messages: Vec<v0::Message> = db
             .fetch_messages(query)
@@ -837,6 +851,7 @@ impl Message {
                             v0::SystemMessage::MessageUnpinned { by, .. } => {
                                 users.push(by.clone());
                             }
+                            v0::SystemMessage::CallStarted { by, .. } => users.push(by.clone()),
                         }
                     }
                     users
@@ -851,7 +866,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)
@@ -1020,6 +1035,31 @@ 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

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

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+use std::time::SystemTime;
 use revolt_result::Result;
 
 use crate::{AppendMessage, FieldsMessage, Message, MessageQuery, PartialMessage};
@@ -40,4 +42,12 @@ 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>>>;
 }

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

@@ -1,8 +1,12 @@
 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,
@@ -306,6 +310,112 @@ 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 {

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

@@ -1,7 +1,9 @@
+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;
@@ -286,4 +288,63 @@ 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)
+    }
 }

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

@@ -7,6 +7,14 @@ 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 {
@@ -30,6 +38,13 @@ 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>
@@ -53,7 +68,10 @@ auto_derived!(
         Avatar,
         Roles,
         Timeout,
+        CanReceive,
+        CanPublish,
         JoinedAt,
+        VoiceChannel,
     }
 
     /// Member removal intention
@@ -73,6 +91,8 @@ impl Default for Member {
             avatar: None,
             roles: vec![],
             timeout: None,
+            can_publish: true,
+            can_receive: true,
         }
     }
 }
@@ -127,6 +147,20 @@ 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(),
@@ -144,6 +178,7 @@ impl Member {
                 .map(|channel| channel.into())
                 .collect(),
             emojis: emojis.into_iter().map(|emoji| emoji.into()).collect(),
+            voice_states,
         }
         .private(user.id.clone())
         .await;
@@ -193,11 +228,14 @@ 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 => {}
         }
     }
 

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

@@ -330,12 +330,15 @@ impl AbstractServerMembers for MongoDb {
 
 impl IntoDocumentPath for FieldsMember {
     fn as_path(&self) -> Option<&'static str> {
-        Some(match self {
-            FieldsMember::JoinedAt => "joined_at",
-            FieldsMember::Avatar => "avatar",
-            FieldsMember::Nickname => "nickname",
-            FieldsMember::Roles => "roles",
-            FieldsMember::Timeout => "timeout",
-        })
+        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,
+        }
     }
 }

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

@@ -68,6 +68,9 @@ 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
@@ -246,7 +249,6 @@ impl Server {
             role.update(
                 db,
                 &self.id,
-                role_id,
                 PartialRole {
                     permissions: Some(permissions),
                     ..Default::default()
@@ -297,6 +299,7 @@ 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,
@@ -306,20 +309,29 @@ impl Role {
     }
 
     /// Create a role
-    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?;
+    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?;
 
         EventV1::ServerRoleUpdate {
-            id: server_id.to_string(),
-            role_id: role_id.to_string(),
-            data: self.clone().into_optional().into(),
+            id: server.id.clone(),
+            role_id: role.id.clone(),
+            data: role.clone().into_optional().into(),
             clear: vec![],
         }
-        .p(server_id.to_string())
+        .p(server.id.clone())
         .await;
 
-        Ok(role_id)
+        Ok(role)
     }
 
     /// Update server data
@@ -327,7 +339,6 @@ impl Role {
         &mut self,
         db: &Database,
         server_id: &str,
-        role_id: &str,
         partial: PartialRole,
         remove: Vec<FieldsRole>,
     ) -> Result<()> {
@@ -337,14 +348,14 @@ impl Role {
 
         self.apply_options(partial.clone());
 
-        db.update_role(server_id, role_id, &partial, remove.clone())
+        db.update_role(server_id, &self.id, &partial, remove.clone())
             .await?;
 
         EventV1::ServerRoleUpdate {
             id: server_id.to_string(),
-            role_id: role_id.to_string(),
+            role_id: self.id.clone(),
             data: partial.into(),
-            clear: vec![],
+            clear: remove.into_iter().map(Into::into).collect(),
         }
         .p(server_id.to_string())
         .await;
@@ -360,15 +371,15 @@ impl Role {
     }
 
     /// Delete a role
-    pub async fn delete(self, db: &Database, server_id: &str, role_id: &str) -> Result<()> {
+    pub async fn delete(self, db: &Database, server_id: &str) -> Result<()> {
         EventV1::ServerRoleDelete {
             id: server_id.to_string(),
-            role_id: role_id.to_string(),
+            role_id: self.id.clone(),
         }
         .p(server_id.to_string())
         .await;
 
-        db.delete_role(server_id, role_id).await
+        db.delete_role(server_id, &self.id).await
     }
 }
 

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

@@ -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_id: &str, role: &Role) -> Result<()>;
+    async fn insert_role(&self, server_id: &str, role: &Role) -> Result<()>;
 
     /// Update an existing role on a server
     async fn update_role(

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

@@ -69,7 +69,7 @@ impl AbstractServers for MongoDb {
     }
 
     /// Insert a new role into server object
-    async fn insert_role(&self, server_id: &str, role_id: &str, role: &Role) -> Result<()> {
+    async fn insert_role(&self, server_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"))?
                     }
                 },

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

@@ -72,10 +72,10 @@ impl AbstractServers for ReferenceDb {
     }
 
     /// Insert a new role into server object
-    async fn insert_role(&self, server_id: &str, role_id: &str, role: &Role) -> Result<()> {
+    async fn insert_role(&self, server_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.to_string(), role.clone());
+            server.roles.insert(role.id.clone(), role.clone());
             Ok(())
         } else {
             Err(create_error!(NotFound))

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

@@ -1,21 +1,20 @@
-use axum::{
-    extract::{FromRef, FromRequestParts},
-    http::request::Parts,
-};
+use axum::{extract::{FromRef, FromRequestParts}, http::request::Parts};
 
 use revolt_result::{create_error, Error, Result};
 
 use crate::{Database, User};
 
 #[async_trait::async_trait]
-impl<S: Send + Sync> FromRequestParts<S> for User
+impl<S> FromRequestParts<S> for User
 where
     Database: FromRef<S>,
+    S: Send + Sync
 {
     type Rejection = Error;
 
     async fn from_request_parts(parts: &mut Parts, state: &S) -> Result<User> {
         let db = Database::from_ref(state);
+
         if let Some(Ok(bot_token)) = parts.headers.get("x-bot-token").map(|v| v.to_str()) {
             let bot = db.fetch_bot_by_token(bot_token).await?;
             db.fetch_user(&bot.id).await

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

@@ -14,7 +14,7 @@ use validator::HasLen;
 use revolt_result::Result;
 
 use super::DelayedTask;
-use crate::Channel::{TextChannel, VoiceChannel};
+use crate::Channel::TextChannel;
 
 /// Enumeration of possible events
 #[derive(Debug, Eq, PartialEq)]
@@ -191,17 +191,14 @@ pub async fn handle_ack_event(
                     .await
                     .expect("Failed to fetch channel from db");
 
-                match channel {
-                    TextChannel { server, .. } | VoiceChannel { server, .. } => {
-                        if let Err(err) =
-                            amqp.mass_mention_message_sent(server, mass_mentions).await
-                        {
-                            revolt_config::capture_error(&err);
-                        }
-                    }
-                    _ => {
-                        panic!("Unknown channel type when sending mass mention event");
+                if let TextChannel { server, .. } = channel {
+                    if let Err(err) =
+                        amqp.mass_mention_message_sent(server, mass_mentions).await
+                    {
+                        revolt_config::capture_error(&err);
                     }
+                } else {
+                    panic!("Unknown channel type when sending mass mention event");
                 }
             }
         }

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

@@ -143,6 +143,7 @@ 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 },
@@ -188,6 +189,8 @@ impl From<crate::Channel> for Channel {
                 default_permissions,
                 role_permissions,
                 nsfw,
+                voice,
+                slowmode
             } => Channel::TextChannel {
                 id,
                 server,
@@ -198,31 +201,15 @@ impl From<crate::Channel> for Channel {
                 default_permissions,
                 role_permissions,
                 nsfw,
-            },
-            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,
+                voice: voice.map(|voice| voice.into()),
+                slowmode
             },
         }
     }
 }
 
 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 },
@@ -268,6 +255,8 @@ impl From<Channel> for crate::Channel {
                 default_permissions,
                 role_permissions,
                 nsfw,
+                voice,
+                slowmode
             } => crate::Channel::TextChannel {
                 id,
                 server,
@@ -278,25 +267,8 @@ impl From<Channel> for crate::Channel {
                 default_permissions,
                 role_permissions,
                 nsfw,
-            },
-            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,
+                voice: voice.map(|voice| voice.into()),
+                slowmode
             },
         }
     }
@@ -315,6 +287,8 @@ 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,
         }
     }
 }
@@ -332,6 +306,8 @@ 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
         }
     }
 }
@@ -342,6 +318,7 @@ 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,
         }
     }
 }
@@ -352,6 +329,7 @@ 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,
         }
     }
 }
@@ -434,9 +412,16 @@ impl From<crate::Metadata> for Metadata {
         match value {
             crate::Metadata::File => Metadata::File,
             crate::Metadata::Text => Metadata::Text,
-            crate::Metadata::Image { width, height } => Metadata::Image {
+            crate::Metadata::Image {
+                width,
+                height,
+                thumbhash,
+                animated,
+            } => Metadata::Image {
                 width: width as usize,
                 height: height as usize,
+                thumbhash,
+                animated,
             },
             crate::Metadata::Video { width, height } => Metadata::Video {
                 width: width as usize,
@@ -452,9 +437,16 @@ impl From<Metadata> for crate::Metadata {
         match value {
             Metadata::File => crate::Metadata::File,
             Metadata::Text => crate::Metadata::Text,
-            Metadata::Image { width, height } => crate::Metadata::Image {
+            Metadata::Image {
+                width,
+                height,
+                thumbhash,
+                animated,
+            } => crate::Metadata::Image {
                 width: width as isize,
                 height: height as isize,
+                thumbhash,
+                animated,
             },
             Metadata::Video { width, height } => crate::Metadata::Video {
                 width: width as isize,
@@ -543,6 +535,9 @@ 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 }
+            }
         }
     }
 }
@@ -639,6 +634,8 @@ 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,
         }
     }
 }
@@ -652,6 +649,8 @@ 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,
         }
     }
 }
@@ -665,6 +664,8 @@ 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,
         }
     }
 }
@@ -678,6 +679,8 @@ 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,
         }
     }
 }
@@ -707,7 +710,10 @@ 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,
         }
     }
 }
@@ -719,7 +725,10 @@ 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,
         }
     }
 }
@@ -911,6 +920,7 @@ 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,
@@ -923,6 +933,7 @@ 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,
@@ -935,6 +946,7 @@ 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,
@@ -947,6 +959,7 @@ 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,
@@ -1387,3 +1400,19 @@ 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<crate::VoiceInformation> for VoiceInformation {
+    fn from(value: crate::VoiceInformation) -> Self {
+        VoiceInformation {
+            max_users: value.max_users,
+        }
+    }
+}

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

@@ -144,10 +144,6 @@ impl<'z> BulkDatabasePermissionQuery<'z> {
                 Channel::TextChannel {
                     default_permissions,
                     ..
-                }
-                | Channel::VoiceChannel {
-                    default_permissions,
-                    ..
                 } => default_permissions.unwrap_or_default().into(),
                 _ => Default::default(),
             }
@@ -156,16 +152,14 @@ impl<'z> BulkDatabasePermissionQuery<'z> {
         }
     }
 
-    #[allow(dead_code)]
+    #[allow(dead_code, deprecated)]
     fn get_channel_type(&mut self) -> ChannelType {
         if let Some(channel) = &self.channel {
             match channel {
                 Channel::DirectMessage { .. } => ChannelType::DirectMessage,
                 Channel::Group { .. } => ChannelType::Group,
                 Channel::SavedMessages { .. } => ChannelType::SavedMessages,
-                Channel::TextChannel { .. } | Channel::VoiceChannel { .. } => {
-                    ChannelType::ServerChannel
-                }
+                Channel::TextChannel { .. } => ChannelType::ServerChannel,
             }
         } else {
             ChannelType::Unknown
@@ -179,9 +173,6 @@ impl<'z> BulkDatabasePermissionQuery<'z> {
             match channel {
                 Channel::TextChannel {
                     role_permissions, ..
-                }
-                | Channel::VoiceChannel {
-                    role_permissions, ..
                 } => role_permissions,
                 _ => panic!("Not supported for non-server channels"),
             }
@@ -208,12 +199,6 @@ 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"),
     };

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

@@ -0,0 +1,24 @@
+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))
+}

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

@@ -1,6 +1,9 @@
 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::*;

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

@@ -185,9 +185,26 @@ 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 {
@@ -199,9 +216,7 @@ impl PermissionQuery for DatabasePermissionQuery<'_> {
                 Cow::Borrowed(Channel::SavedMessages { .. })
                 | Cow::Owned(Channel::SavedMessages { .. }) => ChannelType::SavedMessages,
                 Cow::Borrowed(Channel::TextChannel { .. })
-                | Cow::Owned(Channel::TextChannel { .. })
-                | Cow::Borrowed(Channel::VoiceChannel { .. })
-                | Cow::Owned(Channel::VoiceChannel { .. }) => ChannelType::ServerChannel,
+                | Cow::Owned(Channel::TextChannel { .. }) => ChannelType::ServerChannel,
             }
         } else {
             ChannelType::Unknown
@@ -225,14 +240,6 @@ 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(),
             }
@@ -250,12 +257,6 @@ 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
@@ -343,11 +344,10 @@ 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::Borrowed(Channel::VoiceChannel { server, .. })
-                | Cow::Owned(Channel::VoiceChannel { server, .. }) => {
+                | Cow::Owned(Channel::TextChannel { 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 :/

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

@@ -0,0 +1,696 @@
+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)
+    }
+}

crates/core/database/src/voice/voice_client.rs

@@ -0,0 +1,162 @@
+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()
+    }
+}

crates/core/database/templates/deletion.html

@@ -1,7 +1,7 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 <html>
   <head>
-    <!-- Compiled with Bootstrap Email version: 1.5.1 --><meta http-equiv="x-ua-compatible" content="ie=edge">
+    <!-- Compiled with Bootstrap Email version: 1.6.0 --><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="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">
+                                    <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">
                                   </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 Revolt<br>
+                              Sent from Stoat<br>
                               Made in Europe
                             </div>
                             <table class="s-6 w-full" role="presentation" border="0" cellpadding="0" cellspacing="0" style="width: 100%;" width="100%">

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

@@ -1,38 +1,37 @@
 <html>
-  <head>
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <style>
-      /* Add custom classes and styles that you want inlined here */
-    </style>
-  </head>
-  <body class="bg-light">
-    <div class="container">
-      <img
-        alt="Revolt Logo"
-        class="ax-center my-10 w-24"
-        src="https://app.revolt.chat/assets/logo_round.png"
-      />
-      <div class="card p-6 p-lg-10 space-y-4">
-        <h1 class="h3 fw-700">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>
+
+<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>
     </div>
-  </body>
-</html>
+    <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>

crates/core/database/templates/deletion.txt

@@ -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 Revolt
+Sent by Stoat
 Made in Europe
 
 Revolt Platforms Ltd. is a company incorporated and registered under the laws of England and Wales.

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

@@ -4,6 +4,6 @@ Please navigate to: {{url}}
 
 This email is intended for {{email}}
 
-This email has no association with Revolt or Revolt Platforms Ltd.
+This email has no association with Stoat or Revolt Platforms Ltd.
 Learn more about third party instances here:
-https://developers.revolt.chat/faq.html
+https://developers.stoat.chat/faq/

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

@@ -1,7 +1,7 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 <html>
   <head>
-    <!-- Compiled with Bootstrap Email version: 1.5.1 --><meta http-equiv="x-ua-compatible" content="ie=edge">
+    <!-- Compiled with Bootstrap Email version: 1.6.0 --><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 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">
+                                    <img class="w-24" src="https://stoat.chat/favicon.svg" alt="Stoat Logo" 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>
@@ -120,7 +120,7 @@
                             </table>
                             <div class="text-muted text-center" style="color: #718096;" align="center">
                               This email is intended for {{email}}<br>
-                              Sent from Revolt<br>
+                              Sent from Stoat<br>
                               Made in Europe
                             </div>
                             <table class="s-6 w-full" role="presentation" border="0" cellpadding="0" cellspacing="0" style="width: 100%;" width="100%">

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

@@ -9,7 +9,8 @@
     <div class="container">
       <img
         class="ax-center my-10 w-24"
-        src="https://app.revolt.chat/assets/logo_round.png"
+        src="https://stoat.chat/favicon.svg"
+        alt="Stoat Logo"
       />
       <div class="card p-6 p-lg-10 space-y-4">
         <h1 class="h3 fw-700">Password Reset</h1>
@@ -25,7 +26,7 @@
       </div>
       <div class="text-muted text-center my-6">
         This email is intended for {{email}}<br />
-        Sent from Revolt<br />
+        Sent from Stoat<br />
         Made in Europe
       </div>
       <div class="text-muted text-xs my-6 ax-center">

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

@@ -8,7 +8,7 @@ password on it, click below to continue.
 Please navigate to: {{url}}
 
 This email is intended for {{email}}
-Sent by Revolt
+Sent by Stoat
 Made in Europe
 
 Revolt Platforms Ltd. is a company incorporated and registered under the laws of England and Wales.

crates/core/database/templates/reset.html

@@ -1,7 +1,7 @@
 <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
 <html>
   <head>
-    <!-- Compiled with Bootstrap Email version: 1.5.1 --><meta http-equiv="x-ua-compatible" content="ie=edge">
+    <!-- Compiled with Bootstrap Email version: 1.6.0 --><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 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">
+                                    <img class="w-24" src="https://stoat.chat/favicon.svg" alt="Stoat Logo" 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>
@@ -104,7 +104,7 @@
                             </table>
                             <div class="text-muted text-center" style="color: #718096;" align="center">
                               This email is intended for {{email}}<br>
-                              Sent from Revolt<br>
+                              Sent from Stoat<br>
                               Made in Europe
                             </div>
                             <table class="s-6 w-full" role="presentation" border="0" cellpadding="0" cellspacing="0" style="width: 100%;" width="100%">

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

@@ -1,34 +1,34 @@
 <html>
-  <head>
-    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
-    <style>
-      /* Add custom classes and styles that you want inlined here */
-    </style>
-  </head>
-  <body class="bg-light">
-    <div class="container">
-      <img
-        class="ax-center my-10 w-24"
-        src="https://app.revolt.chat/assets/logo_round.png"
-      />
-      <div class="card p-6 p-lg-10 space-y-4">
-        <h1 class="h3 fw-700">Password Reset</h1>
-        <p>You requested a password reset, click below to continue.</p>
-        <a class="btn btn-primary p-3 fw-700" href="{{url}}">Reset</a>
-      </div>
-      <div class="text-muted text-center my-6">
-        This email is intended for {{email}}<br />
-        Sent from Revolt<br />
-        Made in Europe
-      </div>
-      <div class="text-muted text-xs my-6 ax-center">
-        Revolt Platforms Ltd. is a company incorporated and registered under the
-        laws of England and Wales.<br />
-        Registered Company Number: 16260658<br />
-        Registered Office:<br />
-        Suite 5703 Unit 3A, 34-35 Hatton Garden,<br />
-        Holborn, United Kingdom, EC1N 8DX
-      </div>
+
+<head>
+  <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />
+  <style>
+    /* Add custom classes and styles that you want inlined here */
+  </style>
+</head>
+
+<body class="bg-light">
+  <div class="container">
+    <img class="ax-center my-10 w-24" src="https://stoat.chat/favicon.svg" alt="Stoat Logo" />
+    <div class="card p-6 p-lg-10 space-y-4">
+      <h1 class="h3 fw-700">Password Reset</h1>
+      <p>You requested a password reset, click below to continue.</p>
+      <a class="btn btn-primary p-3 fw-700" href="{{url}}">Reset</a>
     </div>
-  </body>
-</html>
+    <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>

crates/core/database/templates/reset.txt

@@ -3,7 +3,7 @@ You requested a password reset, if you did not perform this action you can safel
 Please navigate to: {{url}}
 
 This email is intended for {{email}}
-Sent by Revolt
+Sent by Stoat
 Made in Europe
 
 Revolt Platforms Ltd. is a company incorporated and registered under the laws of England and Wales.