chore(images): Build all images.

.config/nextest.toml

@@ -1,2 +1,2 @@
 [profile.default]
-slow-timeout = { period = "5s", terminate-after = 10 }
+slow-timeout = { period = "3s", terminate-after = 2 }

.github/workflows/book.yml

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

.github/workflows/docker.yaml

@@ -1,221 +1,113 @@
-name: Docker Test & Publish
+name: Docker
 
 on:
   push:
-    tags:
-      - "*"
+    branches:
+    - "handmade"
   pull_request:
-    paths:
-      - "Dockerfile"
-  workflow_dispatch:
+    branches:
+    - "handmade"
+  release:
+    types:
+    - published
 
 permissions:
-  contents: read
-  packages: write
-
-concurrency:
-  group: ${{ github.head_ref || github.ref }}
-  cancel-in-progress: true
+    contents: read
 
 jobs:
-  base:
-    name: Test base image build
-    runs-on: arc-runner-set
-    if: github.event_name == 'pull_request'
-    steps:
-      # Configure build environment
-      - name: Checkout
-        uses: actions/checkout@v3
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
+    # Builds the shared base image: the whole Rust workspace compiled once.
+    # Every service image (currently only pushd) is derived from this so the
+    # workspace is built a single time per release. On non-release events this
+    # still runs as a compile check, but nothing is pushed.
+    base:
+        runs-on: ubuntu-latest
+        steps:
+            - name: Checkout
+              uses: actions/checkout@v4
+            - name: Set up Docker Buildx
+              uses: docker/setup-buildx-action@v3
+            - name: Resolve registry host and owner
+              id: registry
+              # Owner is lowercased: Docker repository names must be lowercase.
+              run: |
+                  echo "host=${GITHUB_SERVER_URL#*://}" >> "$GITHUB_OUTPUT"
+                  echo "owner=$(echo "$GITHUB_REPOSITORY_OWNER" | tr '[:upper:]' '[:lower:]')" >> "$GITHUB_OUTPUT"
+            - name: Base image ref
+              id: base
+              run: echo "image=${{ steps.registry.outputs.host }}/${{ steps.registry.outputs.owner }}/handmade-revolt-backend-base" >> "$GITHUB_OUTPUT"
+            - name: Login to registry
+              uses: docker/login-action@v3
+              if: github.event_name == 'release'
+              with:
+                  registry: ${{ steps.registry.outputs.host }}
+                  username: ${{ secrets.PACKAGE_PUBLISH_USERNAME }}
+                  password: ${{ secrets.PACKAGE_PUBLISH_TOKEN }}
+            - name: Build base image
+              uses: docker/build-push-action@v6
+              with:
+                  context: .
+                  file: Dockerfile
+                  push: ${{ github.event_name == 'release' }}
+                  platforms: linux/amd64
+                  # Pinned to the commit so the publish job below consumes this
+                  # exact base.
+                  tags: |
+                      ${{ steps.base.outputs.image }}:latest
+                      ${{ steps.base.outputs.image }}:${{ github.sha }}
 
-      # Build the image
-      - name: Build base image
-        uses: docker/build-push-action@v4
-        with:
-          context: .
-          push: false
-          platforms: linux/amd64,linux/arm64
-          tags: ghcr.io/${{ github.repository_owner }}/base:latest
-          cache-from: type=gha,scope=buildx-base-multi-arch
-          cache-to: type=gha,scope=buildx-base-multi-arch,mode=max
-
-  publish:
-    runs-on: arc-runner-set
-    if: github.event_name != 'pull_request'
-    name: Publish Docker images
-    steps:
-      # Configure build environment
-      - name: Checkout
-        uses: actions/checkout@v3
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v2
-
-      # Authenticate with Docker Hub and GHCR
-      - name: Login to Github Container Registry
-        uses: docker/login-action@v2
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-
-      # Build the image
-      - name: Build base image
-        uses: docker/build-push-action@v4
-        with:
-          context: .
-          push: true
-          platforms: linux/amd64,linux/arm64
-          tags: ghcr.io/${{ github.repository_owner }}/base:latest
-
-      # stoatchat/api
-      - name: Docker meta
-        id: meta-delta
-        uses: docker/metadata-action@v4
-        with:
-          images: |
-            ghcr.io/stoatchat/api
-      - name: Publish
-        uses: docker/build-push-action@v4
-        with:
-          context: .
-          push: true
-          platforms: linux/amd64,linux/arm64
-          file: crates/delta/Dockerfile
-          tags: ${{ steps.meta-delta.outputs.tags }}
-          build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
-          labels: ${{ steps.meta-delta.outputs.labels }}
-
-      # stoatchat/events
-      - name: Docker meta
-        id: meta-bonfire
-        uses: docker/metadata-action@v4
-        with:
-          images: |
-            ghcr.io/stoatchat/events
-      - name: Publish
-        uses: docker/build-push-action@v4
-        with:
-          context: .
-          push: true
-          platforms: linux/amd64,linux/arm64
-          file: crates/bonfire/Dockerfile
-          tags: ${{ steps.meta-bonfire.outputs.tags }}
-          build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
-          labels: ${{ steps.meta-bonfire.outputs.labels }}
-
-      # stoatchat/file-server
-      - name: Docker meta
-        id: meta-autumn
-        uses: docker/metadata-action@v4
-        with:
-          images: |
-            ghcr.io/stoatchat/file-server
-      - name: Publish
-        uses: docker/build-push-action@v4
-        with:
-          context: .
-          push: true
-          platforms: linux/amd64,linux/arm64
-          file: crates/services/autumn/Dockerfile
-          tags: ${{ steps.meta-autumn.outputs.tags }}
-          build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
-          labels: ${{ steps.meta-autumn.outputs.labels }}
-
-      # stoatchat/proxy
-      - name: Docker meta
-        id: meta-january
-        uses: docker/metadata-action@v4
-        with:
-          images: |
-            ghcr.io/stoatchat/proxy
-      - name: Publish
-        uses: docker/build-push-action@v4
-        with:
-          context: .
-          push: true
-          platforms: linux/amd64,linux/arm64
-          file: crates/services/january/Dockerfile
-          tags: ${{ steps.meta-january.outputs.tags }}
-          build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
-          labels: ${{ steps.meta-january.outputs.labels }}
-
-      # 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: |
-            ghcr.io/stoatchat/crond
-      - name: Publish
-        uses: docker/build-push-action@v4
-        with:
-          context: .
-          push: true
-          platforms: linux/amd64,linux/arm64
-          file: crates/daemons/crond/Dockerfile
-          tags: ${{ steps.meta-crond.outputs.tags }}
-          build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
-          labels: ${{ steps.meta-crond.outputs.labels }}
-
-      # stoatchat/pushd
-      - name: Docker meta
-        id: meta-pushd
-        uses: docker/metadata-action@v4
-        with:
-          images: |
-            ghcr.io/stoatchat/pushd
-      - name: Publish
-        uses: docker/build-push-action@v4
-        with:
-          context: .
-          push: true
-          platforms: linux/amd64,linux/arm64
-          file: crates/daemons/pushd/Dockerfile
-          tags: ${{ steps.meta-pushd.outputs.tags }}
-          build-args: |
-            BASE_IMAGE=ghcr.io/${{ github.repository_owner }}/base:latest
-          labels: ${{ steps.meta-pushd.outputs.labels }}
-
-      # 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 }}
+    # Builds individual service images from the base. Only runs on release.
+    publish:
+        needs: [base]
+        runs-on: ubuntu-latest
+        if: github.event_name == 'release'
+        strategy:
+            matrix:
+                include:
+                    - { project: pushd,   path: crates/daemons/pushd,     image: handmade-revolt-backend-pushd }
+                    - { project: delta,   path: crates/delta,             image: handmade-revolt-backend-server  }
+                    - { project: bonfire, path: crates/bonfire,           image: handmade-revolt-backend-bonfire }
+                    - { project: autumn,  path: crates/services/autumn,   image: handmade-revolt-backend-autumn  }
+                    - { project: january, path: crates/services/january,  image: handmade-revolt-backend-january }
+                    - { project: crond,   path: crates/daemons/crond,     image: handmade-revolt-backend-crond   }
+        name: Build ${{ matrix.project }} image
+        steps:
+            - name: Checkout
+              uses: actions/checkout@v4
+            - name: Set up Docker Buildx
+              uses: docker/setup-buildx-action@v3
+            - name: Resolve registry host and owner
+              id: registry
+              # Owner is lowercased: Docker repository names must be lowercase,
+              # but the org (e.g. HMC) may be uppercase.
+              run: |
+                  echo "host=${GITHUB_SERVER_URL#*://}" >> "$GITHUB_OUTPUT"
+                  echo "owner=$(echo "$GITHUB_REPOSITORY_OWNER" | tr '[:upper:]' '[:lower:]')" >> "$GITHUB_OUTPUT"
+            - name: Docker meta
+              id: meta
+              uses: docker/metadata-action@v5
+              with:
+                  images: ${{ steps.registry.outputs.host }}/${{ steps.registry.outputs.owner }}/${{ matrix.image }}
+                  tags: |
+                      type=semver,pattern={{version}}
+                      type=semver,pattern={{major}}.{{minor}}
+                      type=raw,value=latest
+              env:
+                  DOCKER_METADATA_ANNOTATIONS_LEVELS: manifest,index
+            - name: Login to registry
+              uses: docker/login-action@v3
+              with:
+                  registry: ${{ steps.registry.outputs.host }}
+                  username: ${{ secrets.PACKAGE_PUBLISH_USERNAME }}
+                  password: ${{ secrets.PACKAGE_PUBLISH_TOKEN }}
+            - name: Build and publish
+              uses: docker/build-push-action@v6
+              with:
+                  context: .
+                  file: ${{ matrix.path }}/Dockerfile
+                  push: true
+                  platforms: linux/amd64
+                  build-args: |
+                      BASE_IMAGE=${{ steps.registry.outputs.host }}/${{ steps.registry.outputs.owner }}/handmade-revolt-backend-base:${{ github.sha }}
+                  tags: ${{ steps.meta.outputs.tags }}
+                  annotations: ${{ steps.meta.outputs.annotations }}
+                  labels: ${{ steps.meta.outputs.labels }}

.github/workflows/docs-test.yml

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

.github/workflows/docs.yml

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

.github/workflows/git-town.yml

@@ -1,19 +0,0 @@
-name: Git Town
-
-on:
-  pull_request:
-
-jobs:
-  git-town:
-    name: Display the branch stack
-    runs-on: ubuntu-slim
-
-    if: ${{ !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

.github/workflows/publish-crates.yml

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

.github/workflows/release-please.yml

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

.github/workflows/release-webhook.yml

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

.github/workflows/triage_issue.yml

@@ -0,0 +1,54 @@
+name: Add Issue to Board
+
+on:
+  issues:
+    types: [opened]
+
+jobs:
+  track_issue:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get project data
+        env:
+          GITHUB_TOKEN: ${{ secrets.PAT }}
+        run: |
+          gh api graphql -f query='
+            query {
+              organization(login: "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

@@ -0,0 +1,79 @@
+name: Add PR to Board
+
+on:
+  pull_request_target:
+    types: [opened, synchronize, ready_for_review, review_requested]
+
+jobs:
+  track_pr:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Get project data
+        env:
+          GITHUB_TOKEN: ${{ secrets.PAT }}
+        run: |
+          gh api graphql -f query='
+            query {
+              organization(login: "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

@@ -1,20 +0,0 @@
-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@v6
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.gitignore

@@ -5,11 +5,8 @@ compose.override.yml
 target
 .data
 .env
-.venv/
-venv/
 
 .vercel
 .DS_Store
 
-livekit.yml
 .idea

.mise/config.toml

@@ -1,19 +0,0 @@
-[tools]
-node = "25.4.0"
-pnpm = "10.28.1"
-
-gh = "2.25.0"
-
-rust = "1.92.0"
-"cargo:cargo-nextest" = "0.9.122"
-
-"github:git-town/git-town" = "22.4.0"
-
-[settings]
-experimental = true
-idiomatic_version_file_enable_tools = ["rust"]
-
-[tasks.start]
-description = "Run all services"
-depends = ["docker:start", "build"]
-run = [{ task = "service:*" }]

.mise/tasks/build

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

.mise/tasks/check

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

.mise/tasks/docker/start

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

.mise/tasks/docker/stop

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

.mise/tasks/docs/_default

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

.mise/tasks/docs/build

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

.mise/tasks/docs/install

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

.mise/tasks/publish

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

.mise/tasks/service/api

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

.mise/tasks/service/crond

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

.mise/tasks/service/events

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

.mise/tasks/service/files

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

.mise/tasks/service/gifbox

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

.mise/tasks/service/proxy

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

.mise/tasks/service/pushd

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

.mise/tasks/test

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

.release-please-manifest.json

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

.vscode/settings.json

@@ -1,6 +1,6 @@
 {
   "editor.formatOnSave": true,
-  "rust-analyzer.check.command": "clippy",
+  "rust-analyzer.checkOnSave.command": "clippy",
   "nixEnvSelector.suggestion": false,
   "nixEnvSelector.nixFile": "${workspaceFolder}/default.nix"
-}
+}

CHANGELOG.md

@@ -1,135 +0,0 @@
-# Changelog
-
-## [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

@@ -6,45 +6,19 @@ members = [
     "crates/bonfire",
     "crates/core/*",
     "crates/services/*",
+    "crates/bindings/*",
     "crates/daemons/*",
 ]
 
 [patch.crates-io]
-redis23 = { package = "redis", version = "0.23.3", git = "https://github.com/revoltchat/redis-rs", rev = "523b2937367e17bd0073722bf6e23d06042cb4e4" }
-#authifier = { package = "authifier", version = "1.0.10", path = "../authifier/crates/authifier" }
-#rocket_authifier = { package = "rocket_authifier", version = "1.0.10", path = "../authifier/crates/rocket_authifier" }
+redis22 = { package = "redis", version = "0.22.3", git = "https://github.com/revoltchat/redis-rs", rev = "1a41faf356fd21aebba71cea7eb7eb2653e5f0ef" }
+redis23 = { package = "redis", version = "0.23.1", git = "https://github.com/revoltchat/redis-rs", rev = "f8ca28ab85da59d2ccde526b4d2fb390eff5a5f9" }
+# authifier = { package = "authifier", version = "1.0.8", path = "../authifier/crates/authifier" }
+# rocket_authifier = { package = "rocket_authifier", version = "1.0.8", path = "../authifier/crates/rocket_authifier" }
 
-[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" }
+# 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.
+# [profile.release]
+# lto = true

Dockerfile

@@ -1,5 +1,5 @@
 # Build Stage
-FROM --platform="${BUILDPLATFORM}" rust:1.92.0-slim-bookworm
+FROM --platform="${BUILDPLATFORM}" rust:1.77.2-slim-bookworm
 USER 0:0
 WORKDIR /home/rust/src
 
@@ -17,24 +17,20 @@ RUN sh /tmp/build-image-layer.sh tools
 
 # Build all dependencies
 COPY Cargo.toml Cargo.lock ./
+COPY crates/bindings/node/Cargo.toml ./crates/bindings/node/
 COPY crates/bonfire/Cargo.toml ./crates/bonfire/
 COPY crates/delta/Cargo.toml ./crates/delta/
 COPY crates/core/config/Cargo.toml ./crates/core/config/
 COPY crates/core/database/Cargo.toml ./crates/core/database/
 COPY crates/core/files/Cargo.toml ./crates/core/files/
 COPY crates/core/models/Cargo.toml ./crates/core/models/
-COPY crates/core/parser/Cargo.toml ./crates/core/parser/
 COPY crates/core/permissions/Cargo.toml ./crates/core/permissions/
 COPY crates/core/presence/Cargo.toml ./crates/core/presence/
 COPY crates/core/result/Cargo.toml ./crates/core/result/
-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.92.0-slim-bookworm
+FROM rust:1.77.2-slim-bookworm
 USER 0:0
 WORKDIR /home/rust/src
 
@@ -13,24 +13,20 @@ COPY scripts/build-image-layer.sh /tmp/
 
 # Build all dependencies
 COPY Cargo.toml Cargo.lock ./
+COPY crates/bindings/node/Cargo.toml ./crates/bindings/node/
 COPY crates/bonfire/Cargo.toml ./crates/bonfire/
 COPY crates/delta/Cargo.toml ./crates/delta/
 COPY crates/core/config/Cargo.toml ./crates/core/config/
 COPY crates/core/database/Cargo.toml ./crates/core/database/
 COPY crates/core/files/Cargo.toml ./crates/core/files/
 COPY crates/core/models/Cargo.toml ./crates/core/models/
-COPY crates/core/parser/Cargo.toml ./crates/core/parser/
 COPY crates/core/permissions/Cargo.toml ./crates/core/permissions/
 COPY crates/core/presence/Cargo.toml ./crates/core/presence/
 COPY crates/core/result/Cargo.toml ./crates/core/result/
-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,6 +1,6 @@
 <div align="center">
 <h1>
-  Stoat Backend
+  Revolt Backend
   
   [![Stars](https://img.shields.io/github/stars/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/stargazers)
   [![Forks](https://img.shields.io/github/forks/revoltchat/backend?style=flat-square&logoColor=white)](https://github.com/revoltchat/backend/network/members)
@@ -12,30 +12,32 @@
 The services and libraries that power the Revolt service.<br/>
 <br/>
 
-| Crate              | Path                                               | Description                         |                                                                                                                                                                                                                                                                                                           |
-| ------------------ | -------------------------------------------------- | ----------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `core/config`      | [crates/core/config](crates/core/config)           | Core: Configuration                 | ![Crates.io Version](https://img.shields.io/crates/v/revolt-config) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-config) ![Crates.io Version](https://img.shields.io/crates/size/revolt-config) ![Crates.io License](https://img.shields.io/crates/l/revolt-config)                     |
-| `core/database`    | [crates/core/database](crates/core/database)       | Core: Database Implementation       | ![Crates.io Version](https://img.shields.io/crates/v/revolt-database) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-database) ![Crates.io Version](https://img.shields.io/crates/size/revolt-database) ![Crates.io License](https://img.shields.io/crates/l/revolt-database)             |
-| `core/files`       | [crates/core/files](crates/core/files)             | Core: S3 and encryption subroutines | ![Crates.io Version](https://img.shields.io/crates/v/revolt-files) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-files) ![Crates.io Version](https://img.shields.io/crates/size/revolt-files) ![Crates.io License](https://img.shields.io/crates/l/revolt-files)                         |
-| `core/models`      | [crates/core/models](crates/core/models)           | Core: API Models                    | ![Crates.io Version](https://img.shields.io/crates/v/revolt-models) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-models) ![Crates.io Version](https://img.shields.io/crates/size/revolt-models) ![Crates.io License](https://img.shields.io/crates/l/revolt-models)                     |
-| `core/permissions` | [crates/core/permissions](crates/core/permissions) | Core: Permission Logic              | ![Crates.io Version](https://img.shields.io/crates/v/revolt-permissions) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-permissions) ![Crates.io Version](https://img.shields.io/crates/size/revolt-permissions) ![Crates.io License](https://img.shields.io/crates/l/revolt-permissions) |
-| `core/presence`    | [crates/core/presence](crates/core/presence)       | Core: User Presence                 | ![Crates.io Version](https://img.shields.io/crates/v/revolt-presence) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-presence) ![Crates.io Version](https://img.shields.io/crates/size/revolt-presence) ![Crates.io License](https://img.shields.io/crates/l/revolt-presence)             |
-| `core/result`      | [crates/core/result](crates/core/result)           | Core: Result and Error types        | ![Crates.io Version](https://img.shields.io/crates/v/revolt-result) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-result) ![Crates.io Version](https://img.shields.io/crates/size/revolt-result) ![Crates.io License](https://img.shields.io/crates/l/revolt-result)                     |
-| `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)                                                                                                                                                                                                                                |
+| Crate              | Path                                               | Description                              |                                                                                                                                                                                                                                                                                                           |
+| ------------------ | -------------------------------------------------- | ---------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `core/config`      | [crates/core/config](crates/core/config)           | Core: Configuration                      | ![Crates.io Version](https://img.shields.io/crates/v/revolt-config) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-config) ![Crates.io Version](https://img.shields.io/crates/size/revolt-config) ![Crates.io License](https://img.shields.io/crates/l/revolt-config)                     |
+| `core/database`    | [crates/core/database](crates/core/database)       | Core: Database Implementation            | ![Crates.io Version](https://img.shields.io/crates/v/revolt-database) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-database) ![Crates.io Version](https://img.shields.io/crates/size/revolt-database) ![Crates.io License](https://img.shields.io/crates/l/revolt-database)             |
+| `core/files`       | [crates/core/files](crates/core/files)             | Core: S3 and encryption subroutines      | ![Crates.io Version](https://img.shields.io/crates/v/revolt-files) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-files) ![Crates.io Version](https://img.shields.io/crates/size/revolt-files) ![Crates.io License](https://img.shields.io/crates/l/revolt-files)                         |
+| `core/models`      | [crates/core/models](crates/core/models)           | Core: API Models                         | ![Crates.io Version](https://img.shields.io/crates/v/revolt-models) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-models) ![Crates.io Version](https://img.shields.io/crates/size/revolt-models) ![Crates.io License](https://img.shields.io/crates/l/revolt-models)                     |
+| `core/permissions` | [crates/core/permissions](crates/core/permissions) | Core: Permission Logic                   | ![Crates.io Version](https://img.shields.io/crates/v/revolt-permissions) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-permissions) ![Crates.io Version](https://img.shields.io/crates/size/revolt-permissions) ![Crates.io License](https://img.shields.io/crates/l/revolt-permissions) |
+| `core/presence`    | [crates/core/presence](crates/core/presence)       | Core: User Presence                      | ![Crates.io Version](https://img.shields.io/crates/v/revolt-presence) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-presence) ![Crates.io Version](https://img.shields.io/crates/size/revolt-presence) ![Crates.io License](https://img.shields.io/crates/l/revolt-presence)             |
+| `core/result`      | [crates/core/result](crates/core/result)           | Core: Result and Error types             | ![Crates.io Version](https://img.shields.io/crates/v/revolt-result) ![Crates.io Version](https://img.shields.io/crates/msrv/revolt-result) ![Crates.io Version](https://img.shields.io/crates/size/revolt-result) ![Crates.io License](https://img.shields.io/crates/l/revolt-result)                     |
+| `delta`            | [crates/delta](crates/delta)                       | REST API server                          | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
+| `bonfire`          | [crates/bonfire](crates/bonfire)                   | WebSocket events server                  | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
+| `services/january` | [crates/services/january](crates/services/january) | Proxy server                             | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
+| `services/autumn`  | [crates/services/autumn](crates/services/autumn)   | File server                              | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
+| `bindings/node`    | [crates/bindings/node](crates/bindings/node)       | Node.js bindings for the Revolt software | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
+| `daemons/crond`    | [crates/daemons/crond](crates/daemons/crond)       | Timed data clean up daemon server        | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
+| `daemons/pushd`    | [crates/daemons/pushd](crates/daemons/pushd)       | Push notification daemon server          | ![License](https://img.shields.io/badge/license-AGPL--3.0--or--later-blue)                                                                                                                                                                                                                                |
 
 </div>
 <br/>
 
 ## Minimum Supported Rust Version
 
-Rust 1.86.0 or higher.
+Rust 1.76 or higher.
+
+> [!CAUTION]
+> The events server has a significant performance regression between Rust 1.77.2 and 1.78.0 onwards, see [issue #341](https://github.com/revoltchat/backend/issues/341).
 
 ## Development Guide
 
@@ -43,13 +45,13 @@ Before contributing, make yourself familiar with [our contribution guidelines](h
 
 Before getting started, you'll want to install:
 
-- mise
+- Rust toolchain (rustup recommended)
 - Docker
 - Git
 - mold (optional, faster compilation)
 
 > A **default.nix** is available for Nix users!
-> Run `nix-shell` to activate mise.
+> Just run `nix-shell` and continue.
 
 As a heads-up, the development environment uses the following ports:
 
@@ -65,14 +67,13 @@ 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
-mise build
+cargo build
 ```
 
 A default configuration `Revolt.toml` is present in this project that is suited for development.
@@ -114,8 +115,7 @@ If you'd like to change anything, create a `Revolt.overrides.toml` file and spec
 > And corresponding Revolt configuration:
 >
 > ```toml
-> #     Revolt.overrides.toml
-> # and Revolt.test-overrides.toml
+> # Revolt.overrides.toml
 > [database]
 > mongodb = "mongodb://127.0.0.1:14017"
 > redis = "redis://127.0.0.1:14079/"
@@ -141,8 +141,6 @@ 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
 

Revolt.toml

@@ -1,5 +1,5 @@
 # ⚠️ This configuration is intended for development environment.
-# If you'd like to override anything, create a Revolt.overrides.toml
+# If you'd like to override anything, create a Revolt.override.toml
 
 [database]
 # MongoDB connection URL
@@ -26,11 +26,6 @@ january = "http://local.revolt.chat:14705"
 voso_legacy = ""
 voso_legacy_ws = ""
 
-# Public urls for livekit nodes
-# each entry here should have a corresponding entry under `api.livekit.nodes`
-[hosts.livekit]
-worldwide = "ws://local.revolt.chat:14706"
-
 [api]
 
 [api.smtp]
@@ -43,19 +38,6 @@ from_address = "development@revolt.chat"
 reply_to = "support@revolt.chat"
 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

STYLE_GUIDE.md

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

compose.yml

@@ -12,10 +12,6 @@ services:
       - "27017:27017"
     volumes:
       - ./.data/db:/data/db
-    ulimits:
-      nofile:
-        soft: 65536
-        hard: 65536
 
   # MinIO
   minio:
@@ -38,13 +34,13 @@ services:
       - minio
     entrypoint: >
       /bin/sh -c "while ! /usr/bin/mc ready minio; do
-        /usr/bin/mc alias set minio http://minio:9000 minioautumn minioautumn;
+        /usr/bin/mc config host add minio http://minio:9000 minioautumn minioautumn;
         echo 'Waiting minio...' && sleep 1;
       done; /usr/bin/mc mb minio/revolt-uploads; exit 0;"
 
   # Rabbit
   rabbit:
-    image: rabbitmq:4-management
+    image: rabbitmq:3-management
     environment:
       RABBITMQ_DEFAULT_USER: rabbituser
       RABBITMQ_DEFAULT_PASS: rabbitpass
@@ -59,7 +55,7 @@ services:
 
   # Mock SMTP server
   maildev:
-    image: maildev/maildev
+    image: soulteary/maildev
     ports:
       - "14025:25"
       - "14080:8080"
@@ -68,10 +64,3 @@ services:
       MAILDEV_WEB_PORT: 8080
       MAILDEV_INCOMING_USER: smtp
       MAILDEV_INCOMING_PASS: smtp
-
-  livekit:
-    image: ghcr.io/stoatchat/livekit-server:v1.9.9
-    command: --config /etc/livekit.yml
-    network_mode: "host"
-    volumes:
-      - ./livekit.yml:/etc/livekit.yml

crates/bindings/node/.gitignore

@@ -0,0 +1,7 @@
+target
+index.node
+**/node_modules
+**/.DS_Store
+npm-debug.log*
+cargo.log
+cross.log

crates/bindings/node/Cargo.toml

@@ -0,0 +1,25 @@
+[package]
+name = "revolt-nodejs-bindings"
+version = "0.8.2"
+description = "Node.js bindings for the Revolt software"
+authors = ["Paul Makles <me@insrt.uk>"]
+license = "MIT"
+edition = "2021"
+exclude = ["index.node"]
+
+[lib]
+crate-type = ["cdylib"]
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+neon = "1.0.0"
+neon-serde4 = "1.0.0"
+
+serde = { version = "1", features = ["derive"] }
+
+async-std = "1.12.0"
+
+revolt-config = { version = "0.8.2", path = "../../core/config" }
+revolt-result = { version = "0.8.2", path = "../../core/result" }
+revolt-database = { version = "0.8.2", path = "../../core/database" }

crates/bindings/node/README.md

@@ -0,0 +1,92 @@
+# revolt.node
+
+**revolt.node:** Node.js bindings for the Revolt software
+
+This project was bootstrapped by [create-neon](https://www.npmjs.com/package/create-neon).
+
+## Building revolt.node
+
+Building revolt.node requires a [supported version of Node and Rust](https://github.com/neon-bindings/neon#platform-support).
+
+To run the build, run:
+
+```sh
+$ npm run build
+```
+
+This command uses the [@neon-rs/cli](https://www.npmjs.com/package/@neon-rs/cli) utility to assemble the binary Node addon from the output of `cargo`.
+
+## Exploring revolt.node
+
+After building revolt.node, you can explore its exports at the Node console:
+
+```sh
+$ npm i
+$ npm run build
+$ node
+> require('.').hello()
+'hello node'
+```
+
+## Available Scripts
+
+In the project directory, you can run:
+
+#### `npm install`
+
+Installs the project, including running `npm run build`.
+
+#### `npm run build`
+
+Builds the Node addon (`index.node`) from source, generating a release build with `cargo --release`.
+
+Additional [`cargo build`](https://doc.rust-lang.org/cargo/commands/cargo-build.html) arguments may be passed to `npm run build` and similar commands. For example, to enable a [cargo feature](https://doc.rust-lang.org/cargo/reference/features.html):
+
+```
+npm run build -- --feature=beetle
+```
+
+#### `npm run debug`
+
+Similar to `npm run build` but generates a debug build with `cargo`.
+
+#### `npm run cross`
+
+Similar to `npm run build` but uses [cross-rs](https://github.com/cross-rs/cross) to cross-compile for another platform. Use the [`CARGO_BUILD_TARGET`](https://doc.rust-lang.org/cargo/reference/config.html#buildtarget) environment variable to select the build target.
+
+#### `npm test`
+
+Runs the unit tests by calling `cargo test`. You can learn more about [adding tests to your Rust code](https://doc.rust-lang.org/book/ch11-01-writing-tests.html) from the [Rust book](https://doc.rust-lang.org/book/).
+
+## Project Layout
+
+The directory structure of this project is:
+
+```
+revolt.node/
+├── Cargo.toml
+├── README.md
+├── src/
+|   └── lib.rs
+├── index.node
+├── package.json
+└── target/
+```
+
+| Entry          | Purpose                                                                                                                                  |
+|----------------|------------------------------------------------------------------------------------------------------------------------------------------|
+| `Cargo.toml`   | The Cargo [manifest file](https://doc.rust-lang.org/cargo/reference/manifest.html), which informs the `cargo` command.                   |
+| `README.md`    | This file.                                                                                                                               |
+| `src/`         | The directory tree containing the Rust source code for the project.                                                                      |
+| `lib.rs`       | Entry point for the Rust source code.                                                                                                          |
+| `index.node`   | The main module, a [Node addon](https://nodejs.org/api/addons.html) generated by the build and pointed to by `"main"` in `package.json`. |
+| `package.json` | The npm [manifest file](https://docs.npmjs.com/cli/v7/configuring-npm/package-json), which informs the `npm` command.                    |
+| `target/`      | Binary artifacts generated by the Rust build.                                                                                            |
+
+## Learn More
+
+Learn more about:
+
+- [Neon](https://neon-bindings.com).
+- [Rust](https://www.rust-lang.org).
+- [Node](https://nodejs.org).

crates/bindings/node/index.d.ts

@@ -0,0 +1,84 @@
+import { Channel, User } from "revolt-api";
+
+/**
+ * Opaque type for Revolt database
+ */
+export declare interface Database {}
+
+/**
+ * Opaque type for Revolt database
+ */
+export declare interface OpaqueUser {}
+
+/**
+ * Error type from Revolt backend
+ */
+export declare interface Err {
+  type: string;
+  location: string;
+}
+
+/**
+ * Initialises background tasks and logging, must be called before anything else!
+ * Can be called multiple times!
+ */
+export declare function init();
+
+/**
+ * Gets a new handle to the Revolt database
+ * @returns {Database} Handle
+ */
+export declare function database(): Database;
+
+/**
+ * Fetch user from database
+ * @param {string} userId User's ID
+ * @this {Database}
+ */
+export declare function database_fetch_user(userId: string): OpaqueUser;
+
+/**
+ * Fetch user from database
+ * @param {string} username Username
+ * @param {string} discriminator Discriminator
+ * @this {Database}
+ */
+export declare function database_fetch_user_by_username(
+  username: string,
+  discriminator: string
+): OpaqueUser;
+
+/**
+ * Gets model data as JSON
+ * @this {OpaqueUser}
+ */
+export declare function model_data(): User;
+
+/**
+ * Gets error if the model failed to fetch
+ * @this {OpaqueUser}
+ */
+export declare function model_error(): Err;
+
+/**
+ * Open a direct message channel between two users
+ * @param {string} userA User A ID
+ * @param {string} userB User B ID
+ * @returns Existing or newly created channel
+ */
+export declare function proc_channels_create_dm(
+  userA: string,
+  userB: string
+): Promise<Channel & { error: Err }>;
+
+/**
+ * Suspend a user
+ * @param {string} user User
+ * @param {number} duration Duration (in days), set to 0 for indefinite
+ * @param {string} reason Pipe-separated list of reasons (e.g. reason1|reason2|reason3)
+ */
+export declare function proc_users_suspend(
+  user: OpaqueUser,
+  duration: number,
+  reason: string
+): Promise<{ error: Err }>;

crates/bindings/node/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "revolt-nodejs-bindings",
+  "version": "0.7.15-rev0.0.3",
+  "description": "Node.js bindings for the Revolt software",
+  "main": "index.node",
+  "scripts": {
+    "test": "cargo test",
+    "cargo-build": "cargo build --message-format=json > cargo.log",
+    "cross-build": "cross build --message-format=json > cross.log",
+    "postcargo-build": "neon dist < cargo.log",
+    "postcross-build": "neon dist -m /target < cross.log",
+    "debug": "npm run cargo-build --",
+    "build": "npm run cargo-build -- --release",
+    "cross": "npm run cross-build -- --release"
+  },
+  "author": "Paul Makles",
+  "license": "AGPL-3.0",
+  "devDependencies": {
+    "@neon-rs/cli": "0.1.73"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/revoltchat/backend"
+  },
+  "keywords": [
+    "revolt",
+    "chat"
+  ],
+  "bugs": {
+    "url": "https://github.com/revoltchat/backend/issues"
+  },
+  "homepage": "https://github.com/revoltchat/backend#readme",
+  "dependencies": {
+    "revolt-api": "^0.7.15"
+  }
+}

crates/bindings/node/pnpm-lock.yaml

@@ -0,0 +1,117 @@
+lockfileVersion: '6.0'
+
+settings:
+  autoInstallPeers: true
+  excludeLinksFromLockfile: false
+
+dependencies:
+  revolt-api:
+    specifier: ^0.7.15
+    version: 0.7.15
+
+devDependencies:
+  '@neon-rs/cli':
+    specifier: 0.1.73
+    version: 0.1.73
+
+packages:
+
+  /@cargo-messages/android-arm-eabi@0.1.72:
+    resolution: {integrity: sha512-gGZxIM1mj+Y5x+ULND6ZCNr7f70OJi9wDlycSK8hGONy9wrChN6JAIHryddC5cqcwlYAoQ6IDcDFElnhAYbybA==}
+    cpu: [arm]
+    os: [android]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@cargo-messages/darwin-arm64@0.1.72:
+    resolution: {integrity: sha512-EAzN5MLaXPljZKZDO5qR+aBs44eSq2ZbEnS7AI/FziE3MzeXbrGOS3fLba5+7yWPFXJyZolXzePm8N1EBv8ovg==}
+    cpu: [arm64]
+    os: [darwin]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@cargo-messages/darwin-x64@0.1.72:
+    resolution: {integrity: sha512-RLo6j8s3nYbjdd1LDct4wamfChyRit7zokUuxtIYCu9XOlltkN5vnj1vwnrPvoqCMZ/7CbbuHFwSTn9A71de/w==}
+    cpu: [x64]
+    os: [darwin]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@cargo-messages/linux-arm-gnueabihf@0.1.72:
+    resolution: {integrity: sha512-tHsRshuzfjrX6SDW3jg6al8vMNLTMgczGnVYl5RuBZf/yrAUuwe30KxA9ge6w6mW6Ox797DyBchzAc9OLgTgmQ==}
+    cpu: [arm]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@cargo-messages/linux-x64-gnu@0.1.72:
+    resolution: {integrity: sha512-VGtL6CCnUbhsP4aYuBNT5kfrAL7o0qjrxw97a+ax13t+nJd26tVEEIKHMu5drvvS/Nm/hn7sLT8zMnnCv0pvHg==}
+    cpu: [x64]
+    os: [linux]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@cargo-messages/win32-arm64-msvc@0.1.72:
+    resolution: {integrity: sha512-V93Cgz39K+yqa3MveNbhh29pYCp8izK5uEavjPoxlNxAbsMCWH+s0verGDdUcfGxjR1H2V7oZ4FszPqR2SqMRQ==}
+    cpu: [arm64]
+    os: [win32]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@cargo-messages/win32-x64-msvc@0.1.72:
+    resolution: {integrity: sha512-knz3uSrO0OSbq3U5VWfCY8FB4NsM43BOWLZ7x4sfaMOC1XWv+IyvDdkLe6DhJx8KUw46KIAimYs9YROrp6l46Q==}
+    cpu: [x64]
+    os: [win32]
+    requiresBuild: true
+    dev: true
+    optional: true
+
+  /@neon-rs/cli@0.1.73:
+    resolution: {integrity: sha512-1kv8S/feB6UQWQQwsnGfkSkEBOtlFDNExnioL81E2BwvUWgjQPaseHgpi2EpWVgsPUgur5eBm4QowmlpWkD4/w==}
+    hasBin: true
+    optionalDependencies:
+      '@cargo-messages/android-arm-eabi': 0.1.72
+      '@cargo-messages/darwin-arm64': 0.1.72
+      '@cargo-messages/darwin-x64': 0.1.72
+      '@cargo-messages/linux-arm-gnueabihf': 0.1.72
+      '@cargo-messages/linux-x64-gnu': 0.1.72
+      '@cargo-messages/win32-arm64-msvc': 0.1.72
+      '@cargo-messages/win32-x64-msvc': 0.1.72
+    dev: true
+
+  /axios@0.26.1:
+    resolution: {integrity: sha512-fPwcX4EvnSHuInCMItEhAGnaSEXRBjtzh9fOtsE6E1G6p7vl7edEeZe11QHf18+6+9gR5PbKV/sGKNaD8YaMeA==}
+    dependencies:
+      follow-redirects: 1.15.6
+    transitivePeerDependencies:
+      - debug
+    dev: false
+
+  /follow-redirects@1.15.6:
+    resolution: {integrity: sha512-wWN62YITEaOpSK584EZXJafH1AGpO8RVgElfkuXbTOrPX4fIfOyEpW/CsiNd8JdYrAoOvafRTOEnvsO++qCqFA==}
+    engines: {node: '>=4.0'}
+    peerDependencies:
+      debug: '*'
+    peerDependenciesMeta:
+      debug:
+        optional: true
+    dev: false
+
+  /lodash.defaultsdeep@4.6.1:
+    resolution: {integrity: sha512-3j8wdDzYuWO3lM3Reg03MuQR957t287Rpcxp1njpEa8oDrikb+FwGdW3n+FELh/A6qib6yPit0j/pv9G/yeAqA==}
+    dev: false
+
+  /revolt-api@0.7.15:
+    resolution: {integrity: sha512-rWRnjBFvoXt/RHRxHg9KuP+x1Jk61KdsOpKOczVJg5tIqGDmqp/6QZHw5rJTtG+wCH3Ah3YKwY+MM5NHfg1W3Q==}
+    dependencies:
+      axios: 0.26.1
+      lodash.defaultsdeep: 4.6.1
+    transitivePeerDependencies:
+      - debug
+    dev: false

crates/bindings/node/src/lib.rs

@@ -0,0 +1,221 @@
+#[macro_use]
+extern crate serde;
+
+use std::sync::OnceLock;
+
+use neon::prelude::*;
+use revolt_database::{Database, DatabaseInfo};
+
+fn js_init(mut cx: FunctionContext) -> JsResult<JsUndefined> {
+    // static INIT: OnceLock<()> = OnceLock::new();
+    // if INIT.get().is_none() {
+    //     INIT.get_or_init(|| {
+    //         async_std::task::block_on(async {
+    //             revolt_config::configure!(api);
+
+    //             match DatabaseInfo::Auto.connect().await {
+    //                 Ok(db) => {
+    //                     let authifier_db = db.clone().to_authifier().await.database;
+    //                     revolt_database::tasks::start_workers(db, authifier_db);
+    //                     Ok(())
+    //                 }
+    //                 Err(err) => Err(err),
+    //             }
+    //         })
+    //         .or_else(|err| cx.throw_error(err))
+    //         .unwrap();
+    //     });
+    // }
+
+    Ok(cx.undefined())
+}
+
+struct DatabaseBinding(Database, Channel);
+impl Finalize for DatabaseBinding {}
+impl DatabaseBinding {
+    fn take(&self) -> (Database, Channel) {
+        (self.0.clone(), self.1.clone())
+    }
+}
+
+fn js_database(mut cx: FunctionContext) -> JsResult<JsBox<DatabaseBinding>> {
+    let db = async_std::task::block_on(DatabaseInfo::Auto.connect())
+        .or_else(|err| cx.throw_error(err))?;
+
+    let channel = cx.channel();
+    Ok(cx.boxed(DatabaseBinding(db, channel)))
+}
+
+// Implementations for models
+#[derive(Clone)]
+#[allow(clippy::large_enum_variant)]
+enum Model {
+    User(revolt_database::User),
+    Error(revolt_result::Error),
+}
+
+impl Model {
+    fn give(&self) -> Model {
+        self.clone()
+    }
+}
+
+impl Finalize for Model {}
+
+macro_rules! shim_boxed {
+    ($cx: ident, $name: ident, $model: ident, $( $variable: ident $type: ident $id: expr )+, $cmd: ident, $( $arg: expr, )+) => {
+        fn $name(mut cx: FunctionContext) -> JsResult<JsPromise> {
+            $(
+                let $variable = cx.argument::<$type>($id)?.value(&mut cx);
+            )+
+
+            let (db, channel) = cx.this::<JsBox<DatabaseBinding>>()?.take();
+            let (deferred, promise) = cx.promise();
+
+            async_std::task::spawn(async move {
+                let result = db.$cmd($($arg,)+).await;
+                deferred.settle_with(&channel, move |mut cx| {
+                    Ok(cx.boxed(match result {
+                        Ok(value) => Model::$model(value),
+                        Err(error) => Model::Error(error)
+                    }))
+                })
+            });
+
+            Ok(promise)
+        }
+
+        $cx.export_function(stringify!($name), $name)?;
+    };
+}
+
+fn js_data(mut cx: FunctionContext) -> JsResult<JsValue> {
+    match cx.this::<JsBox<Model>>()?.give() {
+        Model::Error(_) => neon_serde4::to_value(&mut cx, &None::<()>),
+        Model::User(user) => neon_serde4::to_value(&mut cx, &user),
+    }
+    .or_else(|e| cx.throw_error(e.to_string()))
+}
+
+fn js_error(mut cx: FunctionContext) -> JsResult<JsValue> {
+    let value = match cx.this::<JsBox<Model>>()?.give() {
+        Model::Error(err) => Some(err),
+        _ => None,
+    };
+
+    neon_serde4::to_value(&mut cx, &value).or_else(|e| cx.throw_error(e.to_string()))
+}
+
+// Basic data implementation
+#[derive(Serialize, Deserialize)]
+struct ResultBinding<T> {
+    #[serde(flatten)]
+    value: Option<T>,
+    error: Option<revolt_result::Error>,
+}
+
+macro_rules! shim {
+    ($cx: ident, $name: ident, $( $variable: ident $type: ident $id: expr )*, $( $model: ident $modelType: ident $modelId: expr )*, | $db: ident | $closure: expr, $( $arg: expr, )+) => {
+        fn $name(mut cx: FunctionContext) -> JsResult<JsPromise> {
+            $(
+                let $variable = cx.argument::<$type>($id)?.value(&mut cx);
+            )*
+
+            $(
+                let mut $model = if let Model::$modelType(value) = cx.argument::<JsBox<Model>>($modelId)?.give() {
+                    value
+                } else {
+                    unreachable!()
+                };
+            )*
+
+            let (db, channel) = cx.this::<JsBox<DatabaseBinding>>()?.take();
+            let (deferred, promise) = cx.promise();
+
+            async_std::task::spawn(async move {
+                #[allow(clippy::redundant_closure_call)]
+                let result = (|$db: $crate::Database| $closure)(db.clone()).await;
+                deferred.settle_with(&channel, move |mut cx| {
+                    neon_serde4::to_value(
+                        &mut cx,
+                        &match result {
+                            Ok(value) => ResultBinding {
+                                value: Some(value),
+                                error: None,
+                            },
+                            Err(error) => ResultBinding {
+                                value: None,
+                                error: Some(error),
+                            },
+                        },
+                    )
+                    .or_else(|e| cx.throw_error(e.to_string()))
+                })
+            });
+
+            Ok(promise)
+        }
+
+        $cx.export_function(stringify!($name), $name)?;
+    };
+}
+
+#[neon::main]
+fn main(mut cx: ModuleContext) -> NeonResult<()> {
+    // initialise required background stuff
+    cx.export_function("init", js_init)?;
+
+    // database & model stuff
+    cx.export_function("database", js_database)?;
+    cx.export_function("model_data", js_data)?;
+    cx.export_function("model_error", js_error)?;
+
+    shim_boxed!(
+        cx,
+        database_fetch_user,
+        User,
+        user_id JsString 0,
+        fetch_user,
+        &user_id,
+    );
+
+    shim_boxed!(
+        cx,
+        database_fetch_user_by_username,
+        User,
+        username JsString 0
+        discriminator JsString 1,
+        fetch_user_by_username,
+        &username, &discriminator,
+    );
+
+    // procedure calls
+    shim!(
+        cx,
+        proc_channels_create_dm,
+        user_a JsString 0
+        user_b JsString 1,
+        ,
+        |db| async move {
+            let user_a = db.fetch_user(&user_a).await?;
+            let user_b = db.fetch_user(&user_b).await?;
+            revolt_database::Channel::create_dm(&db, &user_a, &user_b).await
+        },
+        &userA, &userB,
+    );
+
+    shim!(
+        cx,
+        proc_users_suspend,
+        duration JsNumber 1
+        reason JsString 2,
+        user User 0,
+        |db| async move {
+            let duration = duration as usize;
+            user.suspend(&db, if duration == 0 { None } else { Some(duration) }, Some(reason.split('|').map(|x| x.to_owned()).collect())).await
+        },
+        &user,
+    );
+
+    Ok(())
+}

crates/bindings/node/test.js

@@ -0,0 +1,53 @@
+const Internal = require(".");
+
+// playing around with class wrapper, not practical
+class Model {
+  constructor(model) {
+    this.model = model;
+  }
+
+  data() {
+    return Internal.model_data.bind(this.model)();
+  }
+
+  error() {
+    return Internal.model_error.bind(this.model)();
+  }
+}
+
+class User extends Model {
+  constructor(db, user) {
+    super(user);
+    this.db = db;
+  }
+}
+
+class Database {
+  constructor() {
+    this.db = Internal.database();
+  }
+
+  async fetchUser(userId) {
+    return new User(
+      this,
+      await Internal.database_fetch_user.bind(this.db)(userId)
+    );
+  }
+
+  async fetchUserByUsername(username, discriminator) {
+    return new User(
+      this,
+      await Internal.database_fetch_user_by_username.bind(this.db)(
+        username,
+        discriminator
+      )
+    );
+  }
+}
+
+const db = new Database();
+db.fetchUserByUsername("dos", "7624").then((user) => console.info(user.data()));
+db.fetchUserByUsername("dos", "1111").then((user) => console.info(user.data()));
+db.fetchUserByUsername("dos", "1111").then((user) =>
+  console.info(user.error())
+);

crates/bindings/package-lock.json

@@ -0,0 +1,6 @@
+{
+  "name": "bindings",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {}
+}

crates/bonfire/Cargo.toml

@@ -1,9 +1,8 @@
 [package]
 name = "revolt-bonfire"
-version = "0.11.3"
+version = "0.8.2"
 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
 
@@ -20,7 +19,6 @@ async-channel = "2.3.1"
 
 # parsing
 querystring = "1.1.0"
-regex = "1.11.1"
 
 # serde
 bincode = "1.3.3"
@@ -38,12 +36,12 @@ async-std = { version = "1.8.0", features = [
 ] }
 
 # core
-authifier = { version = "1.0.16" }
+authifier = { version = "1.0.9" }
 revolt-result = { path = "../core/result" }
 revolt-models = { path = "../core/models" }
 revolt-config = { path = "../core/config" }
-revolt-database = { path = "../core/database", features = ["voice"] }
-revolt-permissions = { path = "../core/permissions" }
+revolt-database = { path = "../core/database" }
+revolt-permissions = { version = "0.8.2", 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/stoatchat/base:latest AS builder
+FROM ghcr.io/revoltchat/base:latest AS builder
 FROM debian:12 AS debian
 
 # Bundle Stage

crates/bonfire/src/config.rs

@@ -1,15 +1,9 @@
 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 {
@@ -23,7 +17,6 @@ pub struct ProtocolConfiguration {
     protocol_version: i32,
     format: ProtocolFormat,
     session_token: Option<String>,
-    ready_payload_fields: ReadyPayloadFields,
 }
 
 impl ProtocolConfiguration {
@@ -32,13 +25,11 @@ 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,
         }
     }
 
@@ -95,8 +86,14 @@ impl ProtocolConfiguration {
     }
 
     /// Get ready payload fields
-    pub fn get_ready_payload_fields(&self) -> &ReadyPayloadFields {
-        &self.ready_payload_fields
+    pub fn get_ready_payload_fields(&self) -> Vec<ReadyPayloadFields> {
+        vec![
+            ReadyPayloadFields::Users,
+            ReadyPayloadFields::Servers,
+            ReadyPayloadFields::Channels,
+            ReadyPayloadFields::Members,
+            ReadyPayloadFields::Emoji,
+        ]
     }
 }
 
@@ -127,23 +124,6 @@ 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 {
@@ -159,31 +139,6 @@ 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,
-                                _ => {}
-                            }
-                        }
-                    }
-                }
                 _ => {}
             }
         }
@@ -196,7 +151,6 @@ impl handshake::server::Callback for WebsocketHandshakeCallback {
                 protocol_version,
                 format,
                 session_token,
-                ready_payload_fields,
             })
             .is_ok()
         {

crates/bonfire/src/events/impl.rs

@@ -1,10 +1,8 @@
-use std::collections::{HashMap, HashSet};
+use std::collections::HashSet;
 
-use futures::future::join_all;
 use revolt_database::{
     events::client::{EventV1, ReadyPayloadFields},
     util::permissions::DatabasePermissionQuery,
-    voice::get_channel_voice_state,
     Channel, Database, Member, MemberCompositeKey, Presence, RelationshipStatus,
 };
 use revolt_models::v0;
@@ -18,9 +16,8 @@ use super::state::{Cache, State};
 impl Cache {
     /// Check whether the current user can view a channel
     pub async fn can_view_channel(&self, db: &Database, channel: &Channel) -> bool {
-        #[allow(deprecated)]
         match &channel {
-            Channel::TextChannel { server, .. } => {
+            Channel::TextChannel { server, .. } | Channel::VoiceChannel { server, .. } => {
                 let member = self.members.get(server);
                 let server = self.servers.get(server);
                 let mut query =
@@ -97,25 +94,11 @@ impl State {
     pub async fn generate_ready_payload(
         &mut self,
         db: &Database,
-        fields: &ReadyPayloadFields,
+        fields: Vec<ReadyPayloadFields>,
     ) -> Result<EventV1> {
         let user = self.clone_user();
         self.cache.is_bot = user.bot.is_some();
 
-        // Fetch pending policy changes.
-        let policy_changes = if user.bot.is_some() || !fields.policy_changes {
-            None
-        } else {
-            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.
         let mut user_ids: HashSet<String> = user
             .relations
@@ -124,7 +107,12 @@ impl State {
             .unwrap_or_default();
 
         // Fetch all memberships with their corresponding servers.
-        let mut members: Vec<Member> = db.fetch_all_memberships(&user.id).await?;
+        let members: Vec<Member> = db.fetch_all_memberships(&user.id).await?;
+        self.cache.members = members
+            .iter()
+            .cloned()
+            .map(|x| (x.id.server.clone(), x))
+            .collect();
 
         let server_ids: Vec<String> = members.iter().map(|x| x.id.server.clone()).collect();
         let servers = db.fetch_servers(&server_ids).await?;
@@ -153,53 +141,6 @@ impl State {
             }
         }
 
-        let voice_states = if fields.voice_states {
-            let mut voice_state_server_members: HashMap<String, HashSet<String>> = HashMap::new();
-
-            // fetch voice states for all the channels we can see
-            let mut voice_states = Vec::new();
-
-            for channel in channels.iter().filter(|c| {
-                matches!(
-                    c,
-                    Channel::DirectMessage { .. }
-                        | Channel::Group { .. }
-                        | Channel::TextChannel { voice: Some(_), .. }
-                )
-            }) {
-                if let Ok(Some(voice_state)) = get_channel_voice_state(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;
 
@@ -213,14 +154,8 @@ impl State {
             )
             .await?;
 
-        self.cache.members = members
-            .iter()
-            .cloned()
-            .map(|x| (x.id.server.clone(), x))
-            .collect();
-
         // Fetch customisations.
-        let emojis = if fields.emojis {
+        let emojis = if fields.contains(&ReadyPayloadFields::Emoji) {
             Some(
                 db.fetch_emoji_by_parent_ids(
                     &servers
@@ -228,34 +163,25 @@ impl State {
                         .map(|x| x.id.to_string())
                         .collect::<Vec<String>>(),
                 )
-                .await?
-                .into_iter()
-                .map(|emoji| emoji.into())
-                .collect(),
+                .await?,
             )
         } else {
             None
         };
 
         // Fetch user settings
-        let user_settings = if !fields.user_settings.is_empty() {
-            Some(
-                db.fetch_user_settings(&user.id, &fields.user_settings)
-                    .await?,
-            )
+        let user_settings = if let Some(ReadyPayloadFields::UserSettings(keys)) = fields
+            .iter()
+            .find(|e| matches!(e, ReadyPayloadFields::UserSettings(_)))
+        {
+            Some(db.fetch_user_settings(&user.id, &keys).await?)
         } else {
             None
         };
 
         // Fetch channel unreads
-        let channel_unreads = if fields.channel_unreads {
-            Some(
-                db.fetch_unreads(&user.id)
-                    .await?
-                    .into_iter()
-                    .map(|unread| unread.into())
-                    .collect(),
-            )
+        let channel_unreads = if fields.contains(&ReadyPayloadFields::ChannelUnreads) {
+            Some(db.fetch_unreads(&user.id).await?)
         } else {
             None
         };
@@ -272,11 +198,13 @@ impl State {
             .collect();
 
         // Make all users appear from our perspective.
-        let mut users: Vec<v0::User> = join_all(users.into_iter().map(|other_user| async {
-            let is_online = online_ids.contains(&other_user.id);
-            other_user.into_known(&user, is_online).await
-        }))
-        .await;
+        let mut users: Vec<v0::User> = users
+            .into_iter()
+            .map(|other_user| {
+                let is_online = online_ids.contains(&other_user.id);
+                other_user.into_known(&user, is_online)
+            })
+            .collect();
 
         // Make sure we see our own user correctly.
         users.push(user.into_self(true).await);
@@ -300,31 +228,31 @@ impl State {
         for channel in &channels {
             self.insert_subscription(channel.id().to_string()).await;
         }
-
         Ok(EventV1::Ready {
-            users: if fields.users { Some(users) } else { None },
-            servers: if fields.servers {
+            users: if fields.contains(&ReadyPayloadFields::Users) {
+                Some(users)
+            } else {
+                None
+            },
+            servers: if fields.contains(&ReadyPayloadFields::Servers) {
                 Some(servers.into_iter().map(Into::into).collect())
             } else {
                 None
             },
-            channels: if fields.channels {
+            channels: if fields.contains(&ReadyPayloadFields::Channels) {
                 Some(channels.into_iter().map(Into::into).collect())
             } else {
                 None
             },
-            members: if fields.members {
+            members: if fields.contains(&ReadyPayloadFields::Members) {
                 Some(members.into_iter().map(Into::into).collect())
             } else {
                 None
             },
-            voice_states,
+            emojis: emojis.map(|vec| vec.into_iter().map(Into::into).collect()),
 
-            emojis,
             user_settings,
-            channel_unreads,
-
-            policy_changes,
+            channel_unreads: channel_unreads.map(|vec| vec.into_iter().map(Into::into).collect()),
         })
     }
 
@@ -337,14 +265,19 @@ impl State {
 
             let id = &id.to_string();
             for (channel_id, channel) in &self.cache.channels {
-                if channel.server() == Some(id) {
-                    channel_ids.insert(channel_id.clone());
+                match channel {
+                    Channel::TextChannel { server, .. } | Channel::VoiceChannel { server, .. } => {
+                        if server == id {
+                            channel_ids.insert(channel_id.clone());
 
-                    if self.cache.can_view_channel(db, channel).await {
-                        added_channels.push(channel_id.clone());
-                    } else {
-                        removed_channels.push(channel_id.clone());
+                            if self.cache.can_view_channel(db, channel).await {
+                                added_channels.push(channel_id.clone());
+                            } else {
+                                removed_channels.push(channel_id.clone());
+                            }
+                        }
                     }
+                    _ => {}
                 }
             }
 
@@ -399,27 +332,27 @@ impl State {
 
     /// Push presence change to the user and all associated server topics
     pub async fn broadcast_presence_change(&self, target: bool) {
-        // if if let Some(status) = &self.cache.users.get(&self.cache.user_id).unwrap().status {
-        //     status.presence != Some(Presence::Invisible)
-        // } else {
-        //     true
-        // } {
-        //     let event = EventV1::UserUpdate {
-        //         id: self.cache.user_id.clone(),
-        //         data: v0::PartialUser {
-        //             online: Some(target),
-        //             ..Default::default()
-        //         },
-        //         clear: vec![],
-        //         event_id: Some(ulid::Ulid::new().to_string()),
-        //     };
+        if if let Some(status) = &self.cache.users.get(&self.cache.user_id).unwrap().status {
+            status.presence != Some(Presence::Invisible)
+        } else {
+            true
+        } {
+            let event = EventV1::UserUpdate {
+                id: self.cache.user_id.clone(),
+                data: v0::PartialUser {
+                    online: Some(target),
+                    ..Default::default()
+                },
+                clear: vec![],
+                event_id: Some(ulid::Ulid::new().to_string()),
+            };
 
-        //     for server in self.cache.servers.keys() {
-        //         event.clone().p(server.clone()).await;
-        //     }
+            for server in self.cache.servers.keys() {
+                event.clone().p(server.clone()).await;
+            }
 
-        //     event.p(self.cache.user_id.clone()).await;
-        // }
+            event.p(self.cache.user_id.clone()).await;
+        }
     }
 
     /// Handle an incoming event for protocol version 1
@@ -512,7 +445,6 @@ impl State {
                 server,
                 channels,
                 emojis: _,
-                voice_states: _,
             } => {
                 self.insert_subscription(id.clone()).await;
 

crates/bonfire/src/websocket.rs

@@ -3,7 +3,7 @@ use std::{collections::HashSet, net::SocketAddr, sync::Arc};
 use async_tungstenite::WebSocketStream;
 use authifier::AuthifierEvent;
 use fred::{
-    error::RedisErrorKind,
+    error::{RedisError, RedisErrorKind},
     interfaces::{ClientLike, EventInterface, PubsubInterface},
     types::RedisConfig,
 };
@@ -17,7 +17,6 @@ use redis_kiss::{PayloadType, REDIS_PAYLOAD_TYPE, REDIS_URI};
 use revolt_config::report_internal_error;
 use revolt_database::{
     events::{client::EventV1, server::ClientMessage},
-    iso8601_timestamp::Timestamp,
     Database, User, UserHint,
 };
 use revolt_presence::{create_session, delete_session};
@@ -101,10 +100,6 @@ pub async fn client(db: &'static Database, stream: TcpStream, addr: SocketAddr)
 
     info!("User {addr:?} authenticated as @{}", user.username);
 
-    db.update_session_last_seen(&session_id, Timestamp::now_utc())
-        .await
-        .ok();
-
     // Create local state.
     let mut state = State::from(user, session_id);
     let user_id = state.cache.user_id.clone();
@@ -457,8 +452,30 @@ async fn worker(
                 };
 
                 match payload {
-                    ClientMessage::BeginTyping { .. } => {}
-                    ClientMessage::EndTyping { .. } => {}
+                    ClientMessage::BeginTyping { channel } => {
+                        if !subscribed.read().await.contains(&channel) {
+                            continue;
+                        }
+
+                        EventV1::ChannelStartTyping {
+                            id: channel.clone(),
+                            user: user_id.clone(),
+                        }
+                        .p(channel.clone())
+                        .await;
+                    }
+                    ClientMessage::EndTyping { channel } => {
+                        if !subscribed.read().await.contains(&channel) {
+                            continue;
+                        }
+
+                        EventV1::ChannelStopTyping {
+                            id: channel.clone(),
+                            user: user_id.clone(),
+                        }
+                        .p(channel.clone())
+                        .await;
+                    }
                     ClientMessage::Subscribe { server_id } => {
                         let mut servers = active_servers.lock().await;
                         let has_item = servers.contains_key(&server_id);

crates/core/coalesced/Cargo.toml

@@ -1,28 +0,0 @@
-[package]
-name = "revolt-coalesced"
-version = "0.11.3"
-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

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

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

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

@@ -1,39 +0,0 @@
-//! # 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

@@ -1,208 +0,0 @@
-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,20 +1,17 @@
 [package]
 name = "revolt-config"
-version = "0.11.3"
+version = "0.8.2"
 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
 
 [features]
-anyhow = ["dep:sentry-anyhow"]
 report-macros = ["revolt-result"]
-sentry = ["dep:sentry"]
 test = ["async-std"]
-default = ["test", "sentry"]
+default = ["test"]
 
 [dependencies]
 # Utility
@@ -34,8 +31,7 @@ log = "0.4.14"
 pretty_env_logger = "0.4.0"
 
 # Sentry
-sentry = { version = "0.31.5", optional = true }
-sentry-anyhow = { version = "0.38.1", optional = true }
+sentry = "0.31.5"
 
 # Core
-revolt-result = { version = "0.11.3", path = "../result", optional = true }
+revolt-result = { version = "0.8.2", path = "../result", optional = true }

crates/core/config/Revolt.test.toml

@@ -7,6 +7,3 @@ host = "127.0.0.1"
 port = 5672
 username = "rabbituser"
 password = "rabbitpass"
-
-[features]
-webhooks_enabled = true

crates/core/config/Revolt.toml

@@ -1,5 +1,3 @@
-production = false
-
 [database]
 # MongoDB connection URL
 # Defaults to the container name specified in self-hosted
@@ -22,8 +20,6 @@ january = "http://local.revolt.chat/january"
 voso_legacy = ""
 voso_legacy_ws = ""
 
-[hosts.livekit]
-
 [rabbit]
 host = "rabbit"
 port = 5672
@@ -56,10 +52,6 @@ authifier_shield_key = ""
 voso_legacy_token = ""
 # Whether services are behind the Cloudflare network
 trust_cloudflare = false
-# easypwned endpoint
-easypwned = ""
-# Tenor API Key
-tenor_key = ""
 
 [api.security.captcha]
 # hCaptcha configuration
@@ -70,34 +62,19 @@ hcaptcha_sitekey = ""
 # Maximum concurrent connections (to proxy server)
 max_concurrent_connections = 50
 
-[api.livekit]
-# How long to ring devices for when calling in dms/groups, in seconds
-call_ring_duration = 30
-
-[api.livekit.nodes]
-
-[api.users]
-
 [pushd]
 # this changes the names of the queues to not overlap 
 # prod/beta if they happen to be on the same exchange/instance.
 # Usually they have to be, so that messages sent from one or the other get sent to everyone
 production = true
 
-# Changes how many users are processed in each chunk when resolving role/everyone mentions.
-# Increasing this will resolve mentions faster, but will consume more memory while resolving.
-mass_mention_chunk_size = 200
-
 # none of these should need changing
 exchange = "revolt.notifications"
 message_queue = "notifications.origin.message"
-mass_mention_queue = "notifications.origin.mass_mention" # handles messages that contain role or everyone mentions
-fr_accepted_queue = "notifications.ingest.fr_accepted"   # friend request accepted
-fr_received_queue = "notifications.ingest.fr_received"   # friend request received
-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
-
+fr_accepted_queue = "notifications.ingest.fr_accepted" # friend request accepted
+fr_received_queue = "notifications.ingest.fr_received" # friend request received
+generic_queue = "notifications.ingest.generic"         # generic messages (title + body)
+ack_queue = "notifications.process.ack"                # updates badges for apple devices
 
 [pushd.vapid]
 queue = "notifications.outbound.vapid"
@@ -194,13 +171,9 @@ default_bucket = "revolt-uploads"
 
 
 [features]
+# Bucket to upload to by default
 # Feature gate options
 webhooks_enabled = false
-# Enable push notifications for mass pings (everyone, online, roles)
-# When false this will still ping in-client but will not send notifications from pushd
-mass_mentions_send_notifications = true
-# Can role/everyone pings be used at all
-mass_mentions_enabled = true
 
 [features.limits]
 
@@ -238,18 +211,6 @@ message_attachments = 5
 # Maximum number of servers the user can create/join
 servers = 50
 
-# Maximum audio frequency (Hz) in voice calls
-voice_quality = 16000
-
-# Whether the user can use video streams in voice calls
-video = true
-
-# Mamimum 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
@@ -277,18 +238,6 @@ message_attachments = 5
 # Maximum number of servers the user can create/join
 servers = 100
 
-# Maximum audio frequency (Hz) in voice calls
-voice_quality = 16000
-
-# Whether the user can use video streams in voice calls
-video = true
-
-# Mamimum 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.default.file_upload_size_limit]
 # Maximum file size limits (in bytes)
 attachments = 20_000_000
@@ -307,9 +256,6 @@ 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,4 +1,4 @@
-use std::{collections::HashMap, path::Path};
+use std::collections::HashMap;
 
 use cached::proc_macro::cached;
 use config::{Config, File, FileFormat};
@@ -6,12 +6,9 @@ use futures_locks::RwLock;
 use once_cell::sync::Lazy;
 use serde::Deserialize;
 
-#[cfg(feature = "sentry")]
 pub use sentry::{capture_error, capture_message, Level};
-#[cfg(feature = "anyhow")]
-pub use sentry_anyhow::capture_anyhow;
 
-#[cfg(all(feature = "report-macros", feature = "sentry"))]
+#[cfg(feature = "report-macros")]
 #[macro_export]
 macro_rules! report_error {
     ( $expr: expr, $error: ident $( $tt:tt )? ) => {
@@ -26,7 +23,7 @@ macro_rules! report_error {
     };
 }
 
-#[cfg(all(feature = "report-macros", feature = "sentry"))]
+#[cfg(feature = "report-macros")]
 #[macro_export]
 macro_rules! capture_internal_error {
     ( $expr: expr ) => {
@@ -37,7 +34,7 @@ macro_rules! capture_internal_error {
     };
 }
 
-#[cfg(all(feature = "report-macros", feature = "sentry"))]
+#[cfg(feature = "report-macros")]
 #[macro_export]
 macro_rules! report_internal_error {
     ( $expr: expr ) => {
@@ -62,9 +59,6 @@ static CONFIG_SEARCH_PATHS: [&str; 3] = [
     "/Revolt.toml",
 ];
 
-/// Path to search for test overrides
-static TEST_OVERRIDE_PATH: &str = "Revolt.test-overrides.toml";
-
 /// Configuration builder
 static CONFIG_BUILDER: Lazy<RwLock<Config>> = Lazy::new(|| {
     RwLock::new({
@@ -78,35 +72,12 @@ static CONFIG_BUILDER: Lazy<RwLock<Config>> = Lazy::new(|| {
                 include_str!("../Revolt.test.toml"),
                 FileFormat::Toml,
             ));
-
-            // recursively search upwards for an overrides file (if there is one)
-            if let Ok(cwd) = std::env::current_dir() {
-                let mut path = Some(cwd.as_path());
-                while let Some(current_path) = path {
-                    let target_path = current_path.join(TEST_OVERRIDE_PATH);
-                    if target_path.exists() {
-                        builder = builder
-                            .add_source(File::new(target_path.to_str().unwrap(), FileFormat::Toml));
-                    }
-
-                    path = current_path.parent();
-                }
-            }
         }
 
-        let cwd = std::env::current_dir().unwrap();
-        let mut cwd: Option<&Path> = Some(&cwd);
-
-        while let Some(path) = cwd {
-            for config_path in CONFIG_SEARCH_PATHS {
-                let config_path = path.join(config_path);
-                if config_path.exists() {
-                    builder = builder
-                        .add_source(File::new(config_path.to_str().unwrap(), FileFormat::Toml));
-                }
+        for path in CONFIG_SEARCH_PATHS {
+            if std::path::Path::new(path).exists() {
+                builder = builder.add_source(File::new(path, FileFormat::Toml));
             }
-
-            cwd = path.parent();
         }
 
         builder.build().unwrap()
@@ -134,7 +105,8 @@ pub struct Hosts {
     pub events: String,
     pub autumn: String,
     pub january: String,
-    pub livekit: HashMap<String, String>,
+    pub voso_legacy: String,
+    pub voso_legacy_ws: String,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -151,7 +123,6 @@ pub struct ApiSmtp {
     pub reply_to: Option<String>,
     pub port: Option<i32>,
     pub use_tls: Option<bool>,
-    pub use_starttls: Option<bool>,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -197,8 +168,6 @@ pub struct ApiSecurity {
     pub voso_legacy_token: String,
     pub captcha: ApiSecurityCaptcha,
     pub trust_cloudflare: bool,
-    pub easypwned: String,
-    pub tenor_key: String,
 }
 
 #[derive(Deserialize, Debug, Clone)]
@@ -206,50 +175,19 @@ 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>,
-}
-
 #[derive(Deserialize, Debug, Clone)]
 pub struct Api {
     pub registration: ApiRegistration,
     pub smtp: ApiSmtp,
     pub security: ApiSecurity,
     pub workers: ApiWorkers,
-    pub livekit: ApiLiveKit,
-    pub users: ApiUsers,
 }
 
 #[derive(Deserialize, Debug, Clone)]
 pub struct Pushd {
     pub production: bool,
     pub exchange: String,
-    pub mass_mention_chunk_size: usize,
-
-    // Queues
     pub message_queue: String,
-    pub mass_mention_queue: String,
-    pub dm_call_queue: String,
     pub fr_accepted_queue: String,
     pub fr_received_queue: String,
     pub generic_queue: String,
@@ -276,14 +214,6 @@ impl Pushd {
         self.get_routing_key(self.message_queue.clone())
     }
 
-    pub fn get_mass_mention_routing_key(&self) -> String {
-        self.get_routing_key(self.mass_mention_queue.clone())
-    }
-
-    pub fn get_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())
     }
@@ -351,10 +281,6 @@ pub struct FeaturesLimits {
     pub message_length: usize,
     pub message_attachments: usize,
     pub servers: usize,
-    pub voice_quality: u32,
-    pub video: bool,
-    pub video_resolution: [u32; 2],
-    pub video_aspect_ratio: [f32; 2],
 
     pub file_upload_size_limit: HashMap<String, usize>,
 }
@@ -388,9 +314,6 @@ impl Default for FeaturesAdvanced {
 pub struct Features {
     pub limits: FeaturesLimitsCollection,
     pub webhooks_enabled: bool,
-    pub mass_mentions_send_notifications: bool,
-    pub mass_mentions_enabled: bool,
-
     #[serde(default)]
     pub advanced: FeaturesAdvanced,
 }
@@ -399,12 +322,9 @@ 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)]
@@ -417,7 +337,6 @@ pub struct Settings {
     pub files: Files,
     pub features: Features,
     pub sentry: Sentry,
-    pub production: bool,
 }
 
 impl Settings {
@@ -445,23 +364,10 @@ pub async fn read() -> Config {
 
 #[cached(time = 30)]
 pub async fn config() -> Settings {
-    let mut config = read().await.try_deserialize::<Settings>().unwrap();
-
-    // inject REDIS_URI for redis-kiss library
-    if std::env::var("REDIS_URL").is_err() {
-        std::env::set_var("REDIS_URI", config.database.redis.clone());
-    }
-
-    // auto-detect production nodes
-    if config.hosts.api.contains("https") && config.hosts.api.contains("revolt.chat") {
-        config.production = true;
-    }
-
-    config
+    read().await.try_deserialize::<Settings>().unwrap()
 }
 
 /// Configure logging and common Rust variables
-#[cfg(feature = "sentry")]
 pub async fn setup_logging(release: &'static str, dsn: String) -> Option<sentry::ClientInitGuard> {
     if std::env::var("RUST_LOG").is_err() {
         std::env::set_var("RUST_LOG", "info");
@@ -471,6 +377,12 @@ pub async fn setup_logging(release: &'static str, dsn: String) -> Option<sentry:
         std::env::set_var("ROCKET_ADDRESS", "0.0.0.0");
     }
 
+    if std::env::var("REDIS_URL").is_err() {
+        // Configure redis-kiss library
+        let config = config().await;
+        std::env::set_var("REDIS_URI", config.database.redis);
+    }
+
     pretty_env_logger::init();
     log::info!("Starting {release}");
 
@@ -487,7 +399,6 @@ pub async fn setup_logging(release: &'static str, dsn: String) -> Option<sentry:
     }
 }
 
-#[cfg(feature = "sentry")]
 #[macro_export]
 macro_rules! configure {
     ($application: ident) => {

crates/core/database/Cargo.toml

@@ -1,50 +1,41 @@
 [package]
 name = "revolt-database"
-version = "0.11.3"
+version = "0.8.2"
 edition = "2021"
 license = "AGPL-3.0-or-later"
 authors = ["Paul Makles <me@insrt.uk>"]
 description = "Revolt Backend: Database Implementation"
-repository = "https://github.com/stoatchat/stoatchat"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [features]
 # Databases
-mongodb = ["dep:mongodb", "bson", "authifier/database-mongodb"]
+mongodb = ["dep:mongodb", "bson"]
 
 # ... Other
 tasks = ["isahc", "linkify", "url-escape"]
-async-std-runtime = ["async-std", "authifier/async-std-runtime"]
-rocket-impl = [
-    "rocket",
-    "schemars",
-    "revolt_okapi",
-    "revolt_rocket_okapi",
-    "authifier/rocket_impl",
-]
-axum-impl = ["axum", "revolt-result/axum"]
+async-std-runtime = ["async-std"]
+rocket-impl = ["rocket", "schemars", "revolt_okapi", "revolt_rocket_okapi"]
+axum-impl = ["axum"]
 redis-is-patched = ["revolt-presence/redis-is-patched"]
-voice = ["livekit-api", "livekit-protocol", "livekit-runtime"]
 
 # Default Features
 default = ["mongodb", "async-std-runtime", "tasks"]
 
 [dependencies]
 # Core
-revolt-config = { version = "0.11.3", path = "../config", features = [
+revolt-config = { version = "0.8.2", path = "../config", features = [
     "report-macros",
 ] }
-revolt-result = { version = "0.11.3", path = "../result" }
-revolt-models = { version = "0.11.3", path = "../models", features = [
+revolt-result = { version = "0.8.2", path = "../result" }
+revolt-models = { version = "0.8.2", path = "../models", features = [
     "validator",
 ] }
-revolt-presence = { version = "0.11.3", path = "../presence" }
-revolt-permissions = { version = "0.11.3", path = "../permissions", features = [
+revolt-presence = { version = "0.8.2", path = "../presence" }
+revolt-permissions = { version = "0.8.2", path = "../permissions", features = [
     "serde",
     "bson",
 ] }
-revolt-parser = { version = "0.11.3", path = "../parser" }
 
 # Utility
 log = "0.4"
@@ -73,7 +64,7 @@ redis-kiss = { version = "0.1.4" }
 
 # Database
 bson = { optional = true, version = "2.1.0" }
-mongodb = { optional = true, version = "3.1.0" }
+mongodb = { optional = true, version = "2.1.0", default-features = false }
 
 # Database Migration
 unicode-segmentation = "1.10.1"
@@ -99,13 +90,13 @@ rocket = { version = "0.5.1", default-features = false, features = [
 revolt_okapi = { version = "0.9.1", optional = true }
 revolt_rocket_okapi = { version = "0.10.0", optional = true }
 
+# Notifications
+fcm_v1 = "0.3.0"
+web-push = "0.10.0"
+revolt_a2 = { version = "0.10", default-features = false, features = ["ring"] }
+
 # Authifier
-authifier = { version = "1.0.16" }
+authifier = { version = "1.0.9", features = ["rocket_impl"] }
 
 # 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/group_with_members.json

@@ -3,21 +3,18 @@
     "_object_type": "User",
     "_id": "__ID:0__",
     "username": "Owner",
-    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
     "discriminator": "0001"
   },
   {
     "_object_type": "User",
     "_id": "__ID:1__",
     "username": "Member",
-    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
     "discriminator": "0001"
   },
   {
     "_object_type": "User",
     "_id": "__ID:2__",
     "username": "Member",
-    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
     "discriminator": "0002"
   },
   {
@@ -26,9 +23,6 @@
     "channel_type": "Group",
     "name": "My Group",
     "owner": "__ID:0__",
-    "recipients": [
-      "__ID:0__",
-      "__ID:1__"
-    ]
+    "recipients": ["__ID:0__", "__ID:1__"]
   }
-]
+]

crates/core/database/fixtures/server_with_roles.json

@@ -3,21 +3,18 @@
     "_object_type": "User",
     "_id": "__ID:0__",
     "username": "Owner",
-    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
     "discriminator": "0001"
   },
   {
     "_object_type": "User",
     "_id": "__ID:1__",
     "username": "Moderator",
-    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
     "discriminator": "0001"
   },
   {
     "_object_type": "User",
     "_id": "__ID:2__",
     "username": "User",
-    "last_acknowledged_policy_change": "2025-06-07T04:04:48+0000",
     "discriminator": "0001"
   },
   {
@@ -42,21 +39,17 @@
     "_id": "__ID:4__",
     "owner": "__ID:0__",
     "name": "Server",
-    "channels": [
-      "__ID:3__"
-    ],
+    "channels": ["__ID:3__"],
     "roles": {
       "__ID:5__": {
-        "_id": "__ID:5__",
         "name": "Moderator",
         "permissions": {
           "a": 545270208,
           "d": 0
         },
-        "rank": 1
+        "rank": 3
       },
       "__ID:6__": {
-        "_id": "__ID:6__",
         "name": "Owner",
         "permissions": {
           "a": 0,
@@ -73,9 +66,7 @@
       "user": "__ID:0__",
       "server": "__ID:4__"
     },
-    "roles": [
-      "__ID:6__"
-    ],
+    "roles": ["__ID:6__"],
     "joined_at": 1698318340195
   },
   {
@@ -84,9 +75,7 @@
       "user": "__ID:1__",
       "server": "__ID:4__"
     },
-    "roles": [
-      "__ID:5__"
-    ],
+    "roles": ["__ID:5__"],
     "joined_at": 1698318340195
   },
   {
@@ -97,4 +86,4 @@
     },
     "joined_at": 1698318340195
   }
-]
+]

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

@@ -2,8 +2,7 @@ use std::collections::HashSet;
 
 use crate::events::rabbit::*;
 use crate::User;
-use amqprs::channel::{BasicPublishArguments, ExchangeDeclareArguments};
-use amqprs::connection::OpenConnectionArguments;
+use amqprs::channel::BasicPublishArguments;
 use amqprs::{channel::Channel, connection::Connection, error::Error as AMQPError};
 use amqprs::{BasicProperties, FieldTable};
 use revolt_models::v0::PushNotification;
@@ -26,35 +25,6 @@ impl AMQP {
         }
     }
 
-    pub async fn new_auto() -> AMQP {
-        let config = revolt_config::config().await;
-
-        let connection = Connection::open(&OpenConnectionArguments::new(
-            &config.rabbit.host,
-            config.rabbit.port,
-            &config.rabbit.username,
-            &config.rabbit.password,
-        ))
-        .await
-        .expect("Failed to connect to RabbitMQ");
-
-        let channel = connection
-            .open_channel(None)
-            .await
-            .expect("Failed to open RabbitMQ channel");
-
-        channel
-            .exchange_declare(
-                ExchangeDeclareArguments::new(&config.pushd.exchange, "direct")
-                    .durable(true)
-                    .finish(),
-            )
-            .await
-            .expect("Failed to declare exchange");
-
-        AMQP::new(connection, channel)
-    }
-
     pub async fn friend_request_accepted(
         &self,
         accepted_request_user: &User,
@@ -200,38 +170,6 @@ impl AMQP {
             .await
     }
 
-    pub async fn mass_mention_message_sent(
-        &self,
-        server_id: String,
-        payload: Vec<PushNotification>,
-    ) -> Result<(), AMQPError> {
-        let config = revolt_config::config().await;
-
-        let payload = MassMessageSentPayload {
-            notifications: payload,
-            server_id,
-        };
-        let payload = to_string(&payload).unwrap();
-
-        let routing_key = config.pushd.get_mass_mention_routing_key();
-
-        debug!(
-            "Sending mass mention payload on channel {}: {}",
-            routing_key, payload
-        );
-
-        self.channel
-            .basic_publish(
-                BasicProperties::default()
-                    .with_content_type("application/json")
-                    .with_persistence(true)
-                    .finish(),
-                payload.into(),
-                BasicPublishArguments::new(&config.pushd.exchange, routing_key.as_str()),
-            )
-            .await
-    }
-
     pub async fn ack_message(
         &self,
         user_id: String,
@@ -270,50 +208,4 @@ impl AMQP {
             )
             .await
     }
-
-    /// # DM Call Update
-    /// Used to send an update about a DM call, eg. start or end of a call.
-    /// Recipients can be used to narrow the scope of recipients, otherwise all recipients will be notified.
-    /// `ended` refers to the ringing period, not necessarily the call itself.
-    pub async fn dm_call_updated(
-        &self,
-        initiator_id: &str,
-        channel_id: &str,
-        started_at: Option<&str>,
-        ended: bool,
-        recipients: Option<Vec<String>>,
-    ) -> Result<(), AMQPError> {
-        let config = revolt_config::config().await;
-
-        let payload = InternalDmCallPayload {
-            payload: DmCallPayload {
-                initiator_id: initiator_id.to_string(),
-                channel_id: channel_id.to_string(),
-                started_at: started_at.map(|f| f.to_string()),
-                ended,
-            },
-            recipients,
-        };
-        let payload = to_string(&payload).unwrap();
-
-        debug!(
-            "Sending dm call update payload on channel {}: {}",
-            config.pushd.get_dm_call_routing_key(),
-            payload
-        );
-
-        self.channel
-            .basic_publish(
-                BasicProperties::default()
-                    .with_content_type("application/json")
-                    .with_persistence(true)
-                    .finish(),
-                payload.into(),
-                BasicPublishArguments::new(
-                    &config.pushd.exchange,
-                    &config.pushd.get_dm_call_routing_key(),
-                ),
-            )
-            .await
-    }
 }

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

@@ -1,21 +1,17 @@
-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;
 
 use authifier::config::Captcha;
 use authifier::config::EmailVerificationConfig;
-use authifier::config::PasswordScanning;
 use authifier::config::ResolveIp;
 use authifier::config::SMTPSettings;
 use authifier::config::Shield;
 use authifier::config::Template;
 use authifier::config::Templates;
-use authifier::config::EmailExpiryConfig;
 use authifier::Authifier;
 use rand::Rng;
 use revolt_config::config;
 
-#[cfg(feature = "mongodb")]
 pub use self::mongodb::*;
 pub use self::reference::*;
 
@@ -28,20 +24,17 @@ pub enum DatabaseInfo {
     /// Use the mock database
     Reference,
     /// Connect to MongoDB
-    #[cfg(feature = "mongodb")]
     MongoDb { uri: String, database_name: String },
     /// Use existing MongoDB connection
-    #[cfg(feature = "mongodb")]
     MongoDbFromClient(::mongodb::Client, String),
 }
 
 /// Database
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 pub enum Database {
     /// Mock database
     Reference(ReferenceDb),
     /// MongoDB database
-    #[cfg(feature = "mongodb")]
     MongoDb(MongoDb),
 }
 
@@ -51,7 +44,7 @@ impl DatabaseInfo {
     pub async fn connect(self) -> Result<Database, String> {
         let config = config().await;
 
-        match self {
+        Ok(match self {
             DatabaseInfo::Auto => {
                 if std::env::var("TEST_DB").is_ok() {
                     DatabaseInfo::Test(format!(
@@ -59,20 +52,16 @@ impl DatabaseInfo {
                         rand::thread_rng().gen_range(1_000_000..10_000_000)
                     ))
                     .connect()
-                    .await
+                    .await?
                 } else if !config.database.mongodb.is_empty() {
-                    #[cfg(feature = "mongodb")]
-                    return DatabaseInfo::MongoDb {
+                    DatabaseInfo::MongoDb {
                         uri: config.database.mongodb,
                         database_name: "revolt".to_string(),
                     }
                     .connect()
-                    .await;
-
-                    #[cfg(not(feature = "mongodb"))]
-                    return Err("MongoDB not enabled.".to_string());
+                    .await?
                 } else {
-                    DatabaseInfo::Reference.connect().await
+                    DatabaseInfo::Reference.connect().await?
                 }
             }
             DatabaseInfo::Test(database_name) => {
@@ -80,36 +69,30 @@ impl DatabaseInfo {
                     .expect("`TEST_DB` environment variable should be set to REFERENCE or MONGODB")
                     .as_str()
                 {
-                    "REFERENCE" => DatabaseInfo::Reference.connect().await,
+                    "REFERENCE" => DatabaseInfo::Reference.connect().await?,
                     "MONGODB" => {
-                        #[cfg(feature = "mongodb")]
-                        return DatabaseInfo::MongoDb {
+                        DatabaseInfo::MongoDb {
                             uri: config.database.mongodb,
                             database_name,
                         }
                         .connect()
-                        .await;
-
-                        #[cfg(not(feature = "mongodb"))]
-                        return Err("MongoDB not enabled.".to_string());
+                        .await?
                     }
                     _ => unreachable!("must specify REFERENCE or MONGODB"),
                 }
             }
-            DatabaseInfo::Reference => Ok(Database::Reference(Default::default())),
-            #[cfg(feature = "mongodb")]
+            DatabaseInfo::Reference => Database::Reference(Default::default()),
             DatabaseInfo::MongoDb { uri, database_name } => {
                 let client = ::mongodb::Client::with_uri_str(uri)
                     .await
                     .map_err(|_| "Failed to init db connection.".to_string())?;
 
-                Ok(Database::MongoDb(MongoDb(client, database_name)))
+                Database::MongoDb(MongoDb(client, database_name))
             }
-            #[cfg(feature = "mongodb")]
             DatabaseInfo::MongoDbFromClient(client, database_name) => {
-                Ok(Database::MongoDb(MongoDb(client, database_name)))
+                Database::MongoDb(MongoDb(client, database_name))
             }
-        }
+        })
     }
 }
 
@@ -119,13 +102,6 @@ impl Database {
         let config = config().await;
 
         let mut auth_config = authifier::Config {
-            password_scanning: if config.api.security.easypwned.is_empty() {
-                Default::default()
-            } else {
-                PasswordScanning::EasyPwned {
-                    endpoint: config.api.security.easypwned,
-                }
-            },
             email_verification: if !config.api.smtp.host.is_empty() {
                 EmailVerificationConfig::Enabled {
                     smtp: SMTPSettings {
@@ -138,77 +114,32 @@ impl Database {
                                 .api
                                 .smtp
                                 .reply_to
-                                .unwrap_or("support@stoat.chat".into()),
+                                .unwrap_or("support@revolt.chat".into()),
                         ),
                         port: config.api.smtp.port,
                         use_tls: config.api.smtp.use_tls,
-                        use_starttls: config.api.smtp.use_starttls,
                     },
-                    expiry: EmailExpiryConfig {
-                        expire_verification: 3600 * 24 * 7,
-                        expire_password_reset: 3600 * 24,
-                        expire_account_deletion: 3600 * 24,
-                    },
-                    templates: if config.production {
-                        Templates {
-                            verify: Template {
-                                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 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 Stoat account, reset your password."
-                                    .into(),
-                                text: include_str!("../../templates/reset-existing.txt").into(),
-                                url: format!("{}/login/reset/", config.hosts.app),
-                                html: Some(
-                                    include_str!("../../templates/reset-existing.html").into(),
-                                ),
-                            },
-                            deletion: Template {
-                                title: "Confirm account deletion.".into(),
-                                text: include_str!("../../templates/deletion.txt").into(),
-                                url: format!("{}/delete/", config.hosts.app),
-                                html: Some(include_str!("../../templates/deletion.html").into()),
-                            },
-                            welcome: None,
-                        }
-                    } else {
-                        Templates {
-                            verify: Template {
-                                title: "Verify your account.".into(),
-                                text: include_str!("../../templates/verify.whitelabel.txt").into(),
-                                url: format!("{}/login/verify/", config.hosts.app),
-                                html: None,
-                            },
-                            reset: Template {
-                                title: "Reset your password.".into(),
-                                text: include_str!("../../templates/reset.whitelabel.txt").into(),
-                                url: format!("{}/login/reset/", config.hosts.app),
-                                html: None,
-                            },
-                            reset_existing: Template {
-                                title: "Reset your password.".into(),
-                                text: include_str!("../../templates/reset.whitelabel.txt").into(),
-                                url: format!("{}/login/reset/", config.hosts.app),
-                                html: None,
-                            },
-                            deletion: Template {
-                                title: "Confirm account deletion.".into(),
-                                text: include_str!("../../templates/deletion.whitelabel.txt")
-                                    .into(),
-                                url: format!("{}/delete/", config.hosts.app),
-                                html: None,
-                            },
-                            welcome: None,
-                        }
+                    expiry: Default::default(),
+                    templates: Templates {
+                        verify: Template {
+                            title: "Verify your Revolt account.".into(),
+                            text: include_str!("../../templates/verify.txt").into(),
+                            url: format!("{}/login/verify/", config.hosts.app),
+                            html: Some(include_str!("../../templates/verify.html").into()),
+                        },
+                        reset: Template {
+                            title: "Reset your Revolt password.".into(),
+                            text: include_str!("../../templates/reset.txt").into(),
+                            url: format!("{}/login/reset/", config.hosts.app),
+                            html: Some(include_str!("../../templates/reset.html").into()),
+                        },
+                        deletion: Template {
+                            title: "Confirm account deletion.".into(),
+                            text: include_str!("../../templates/deletion.txt").into(),
+                            url: format!("{}/delete/", config.hosts.app),
+                            html: Some(include_str!("../../templates/deletion.html").into()),
+                        },
+                        welcome: None,
                     },
                 }
             } else {
@@ -239,16 +170,12 @@ impl Database {
         Authifier {
             database: match self {
                 Database::Reference(_) => Default::default(),
-                #[cfg(feature = "mongodb")]
                 Database::MongoDb(MongoDb(client, _)) => authifier::Database::MongoDb(
                     authifier::database::MongoDb(client.database("revolt")),
                 ),
             },
             config: auth_config,
-            #[cfg(feature = "tasks")]
             event_channel: Some(crate::tasks::authifier_relay::sender()),
-            #[cfg(not(feature = "tasks"))]
-            event_channel: None,
         }
     }
 }

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

@@ -10,8 +10,8 @@ use serde::de::DeserializeOwned;
 use serde::Serialize;
 
 database_derived!(
+    #[cfg(feature = "mongodb")]
     /// MongoDB implementation
-    #[derive(Debug)]
     pub struct MongoDb(pub ::mongodb::Client, pub String);
 );
 
@@ -31,17 +31,17 @@ impl MongoDb {
     }
 
     /// Get a collection by its name
-    pub fn col<T: Send + Sync>(&self, collection: &str) -> mongodb::Collection<T> {
+    pub fn col<T>(&self, collection: &str) -> mongodb::Collection<T> {
         self.db().collection(collection)
     }
 
     /// Insert one document into a collection
-    pub async fn insert_one<T: Serialize + Send + Sync>(
+    pub async fn insert_one<T: Serialize>(
         &self,
         collection: &'static str,
         document: T,
     ) -> Result<InsertOneResult> {
-        self.col::<T>(collection).insert_one(document).await
+        self.col::<T>(collection).insert_one(document, None).await
     }
 
     /// Count documents by projection
@@ -51,7 +51,7 @@ impl MongoDb {
         projection: Document,
     ) -> Result<u64> {
         self.col::<Document>(collection)
-            .count_documents(projection)
+            .count_documents(projection, None)
             .await
     }
 
@@ -67,8 +67,7 @@ impl MongoDb {
     {
         Ok(self
             .col::<T>(collection)
-            .find(projection)
-            .with_options(options)
+            .find(projection, options)
             .await?
             .filter_map(|s| async {
                 if cfg!(debug_assertions) {
@@ -102,8 +101,7 @@ impl MongoDb {
         O: Into<Option<FindOneOptions>>,
     {
         self.col::<T>(collection)
-            .find_one(projection)
-            .with_options(options)
+            .find_one(projection, options)
             .await
     }
 
@@ -167,7 +165,7 @@ impl MongoDb {
         };
 
         self.col::<Document>(collection)
-            .update_one(projection, query)
+            .update_one(projection, query, None)
             .await
     }
 
@@ -202,7 +200,7 @@ impl MongoDb {
         projection: Document,
     ) -> Result<DeleteResult> {
         self.col::<Document>(collection)
-            .delete_one(projection)
+            .delete_one(projection, None)
             .await
     }
 

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

@@ -4,13 +4,13 @@ use futures::lock::Mutex;
 
 use crate::{
     Bot, Channel, ChannelCompositeKey, ChannelUnread, Emoji, File, FileHash, Invite, Member,
-    MemberCompositeKey, Message, PolicyChange, RatelimitEvent, Report, Server, ServerBan, Snapshot,
-    User, UserSettings, Webhook,
+    MemberCompositeKey, Message, RatelimitEvent, Report, Server, ServerBan, Snapshot, User,
+    UserSettings, Webhook,
 };
 
 database_derived!(
     /// Reference implementation
-    #[derive(Default, Debug)]
+    #[derive(Default)]
     pub struct ReferenceDb {
         pub bots: Arc<Mutex<HashMap<String, Bot>>>,
         pub channels: Arc<Mutex<HashMap<String, Channel>>>,
@@ -21,7 +21,6 @@ database_derived!(
         pub file_hashes: Arc<Mutex<HashMap<String, FileHash>>>,
         pub files: Arc<Mutex<HashMap<String, File>>>,
         pub messages: Arc<Mutex<HashMap<String, Message>>>,
-        pub policy_changes: Arc<Mutex<HashMap<String, PolicyChange>>>,
         pub ratelimit_events: Arc<Mutex<HashMap<String, RatelimitEvent>>>,
         pub user_settings: Arc<Mutex<HashMap<String, UserSettings>>>,
         pub users: Arc<Mutex<HashMap<String, User>>>,

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

@@ -3,7 +3,10 @@ use revolt_result::Error;
 use serde::{Deserialize, Serialize};
 
 use revolt_models::v0::{
-    AppendMessage, Channel, ChannelUnread, ChannelVoiceState, Emoji, FieldsChannel, FieldsMember, FieldsMessage, FieldsRole, FieldsServer, FieldsUser, FieldsWebhook, Member, MemberCompositeKey, Message, PartialChannel, PartialMember, PartialMessage, PartialRole, PartialServer, PartialUser, PartialUserVoiceState, PartialWebhook, PolicyChange, RemovalIntention, Report, Server, User, UserSettings, UserVoiceState, Webhook
+    AppendMessage, Channel, ChannelUnread, Emoji, FieldsChannel, FieldsMember, FieldsMessage,
+    FieldsRole, FieldsServer, FieldsUser, FieldsWebhook, Member, MemberCompositeKey, Message,
+    PartialChannel, PartialMember, PartialMessage, PartialRole, PartialServer, PartialUser,
+    PartialWebhook, RemovalIntention, Report, Server, User, UserSettings, Webhook,
 };
 
 use crate::Database;
@@ -17,33 +20,16 @@ pub enum Ping {
 }
 
 /// Fields provided in Ready payload
-#[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,
-}
+#[derive(PartialEq)]
+pub enum ReadyPayloadFields {
+    Users,
+    Servers,
+    Channels,
+    Members,
+    Emoji,
 
-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,
-        }
-    }
+    UserSettings(Vec<String>),
+    ChannelUnreads,
 }
 
 /// Protocol Events
@@ -71,16 +57,11 @@ 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>>,
-
-        #[serde(skip_serializing_if = "Option::is_none")]
-        policy_changes: Option<Vec<PolicyChange>>,
     },
 
     /// Ping response
@@ -139,7 +120,6 @@ pub enum EventV1 {
         server: Server,
         channels: Vec<Channel>,
         emojis: Vec<Emoji>,
-        voice_states: Vec<ChannelVoiceState>
     },
 
     /// Update existing server
@@ -162,13 +142,7 @@ pub enum EventV1 {
     },
 
     /// User joins server
-    ServerMemberJoin {
-        id: String,
-        // Deprecated: use member.id.user
-        #[deprecated = "Use member.id.user instead"]
-        user: String,
-        member: Member,
-    },
+    ServerMemberJoin { id: String, user: String },
 
     /// User left server
     ServerMemberLeave {
@@ -189,9 +163,6 @@ pub enum EventV1 {
     /// Server role deleted
     ServerRoleDelete { id: String, role_id: String },
 
-    /// Server roles ranks updated
-    ServerRoleRanksUpdate { id: String, ranks: Vec<String> },
-
     /// Update existing user
     UserUpdate {
         id: String,
@@ -272,33 +243,6 @@ pub enum EventV1 {
 
     /// Auth events
     Auth(AuthifierEvent),
-
-    /// Voice events
-    VoiceChannelJoin {
-        id: String,
-        state: UserVoiceState,
-    },
-    VoiceChannelLeave {
-        id: String,
-        user: String,
-    },
-    VoiceChannelMove {
-        user: String,
-        from: String,
-        to: String,
-        state: UserVoiceState
-    },
-    UserVoiceStateUpdate {
-        id: String,
-        channel_id: String,
-        data: PartialUserVoiceState,
-    },
-    UserMoveVoiceChannel {
-        node: String,
-        from: String,
-        to: String,
-        token: String,
-    }
 }
 
 impl EventV1 {

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

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

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

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

crates/core/database/src/lib.rs

@@ -25,9 +25,6 @@ pub use mongodb;
 #[macro_use]
 extern crate bson;
 
-#[cfg(not(feature = "async-std-runtime"))]
-compile_error!("async-std-runtime feature must be enabled.");
-
 #[macro_export]
 #[cfg(debug_assertions)]
 macro_rules! query {
@@ -106,16 +103,11 @@ pub mod util;
 pub use models::*;
 
 pub mod events;
-#[cfg(feature = "tasks")]
 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.rs

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

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

@@ -10,7 +10,7 @@ impl AbstractMigrations for MongoDb {
     #[cfg(test)]
     /// Drop the database
     async fn drop_database(&self) {
-        self.db().drop().await.ok();
+        self.db().drop(None).await.ok();
     }
 
     /// Migrate the database
@@ -18,7 +18,7 @@ impl AbstractMigrations for MongoDb {
         info!("Migrating the database.");
 
         let list = self
-            .list_database_names()
+            .list_database_names(None, None)
             .await
             .expect("Failed to fetch database names.");
 

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

@@ -8,258 +8,278 @@ pub async fn create_database(db: &MongoDb) {
     info!("Creating database.");
     let db = db.db();
 
-    db.create_collection("accounts")
+    db.create_collection("accounts", None)
         .await
         .expect("Failed to create accounts collection.");
 
-    db.create_collection("users")
+    db.create_collection("users", None)
         .await
         .expect("Failed to create users collection.");
 
-    db.create_collection("channels")
+    db.create_collection("channels", None)
         .await
         .expect("Failed to create channels collection.");
 
-    db.create_collection("messages")
+    db.create_collection("messages", None)
         .await
         .expect("Failed to create messages collection.");
 
-    db.create_collection("servers")
+    db.create_collection("servers", None)
         .await
         .expect("Failed to create servers collection.");
 
-    db.create_collection("server_members")
+    db.create_collection("server_members", None)
         .await
         .expect("Failed to create server_members collection.");
 
-    db.create_collection("server_bans")
+    db.create_collection("server_bans", None)
         .await
         .expect("Failed to create server_bans collection.");
 
-    db.create_collection("channel_invites")
+    db.create_collection("channel_invites", None)
         .await
         .expect("Failed to create channel_invites collection.");
 
-    db.create_collection("channel_unreads")
+    db.create_collection("channel_unreads", None)
         .await
         .expect("Failed to create channel_unreads collection.");
 
-    db.create_collection("channel_webhooks")
+    db.create_collection("channel_webhooks", None)
         .await
         .expect("Failed to create channel_webhooks collection.");
 
-    db.create_collection("migrations")
+    db.create_collection("migrations", None)
         .await
         .expect("Failed to create migrations collection.");
 
-    db.create_collection("attachments")
+    db.create_collection("attachments", None)
         .await
         .expect("Failed to create attachments collection.");
 
-    db.create_collection("attachment_hashes")
+    db.create_collection("attachment_hashes", None)
         .await
         .expect("Failed to create attachment_hashes collection.");
 
-    db.create_collection("user_settings")
+    db.create_collection("user_settings", None)
         .await
         .expect("Failed to create user_settings collection.");
 
-    db.create_collection("policy_changes")
-        .await
-        .expect("Failed to create policy_changes collection.");
-
-    db.create_collection("safety_reports")
+    db.create_collection("safety_reports", None)
         .await
         .expect("Failed to create safety_reports collection.");
 
-    db.create_collection("safety_snapshots")
+    db.create_collection("safety_snapshots", None)
         .await
         .expect("Failed to create safety_snapshots collection.");
 
-    db.create_collection("safety_strikes")
+    db.create_collection("safety_strikes", None)
         .await
         .expect("Failed to create safety_strikes collection.");
 
-    db.create_collection("bots")
+    db.create_collection("bots", None)
         .await
         .expect("Failed to create bots collection.");
 
-    db.create_collection("ratelimit_events")
+    db.create_collection("ratelimit_events", None)
         .await
         .expect("Failed to create ratelimit_events collection.");
 
-    db.create_collection("pubsub")
-        .with_options(
-            CreateCollectionOptions::builder()
-                .capped(true)
-                .size(1_000_000)
-                .build(),
-        )
-        .await
-        .expect("Failed to create pubsub collection.");
+    db.create_collection(
+        "pubsub",
+        CreateCollectionOptions::builder()
+            .capped(true)
+            .size(1_000_000)
+            .build(),
+    )
+    .await
+    .expect("Failed to create pubsub collection.");
 
-    db.run_command(doc! {
-        "createIndexes": "users",
-        "indexes": [
-            {
-                "key": {
-                    "username": 1_i32
+    db.run_command(
+        doc! {
+            "createIndexes": "users",
+            "indexes": [
+                {
+                    "key": {
+                        "username": 1_i32
+                    },
+                    "name": "username",
+                    "unique": false,
+                    "collation": {
+                        "locale": "en",
+                        "strength": 2_i32
+                    }
                 },
-                "name": "username",
-                "unique": false,
-                "collation": {
-                    "locale": "en",
-                    "strength": 2_i32
+                {
+                    "key": {
+                        "username": 1_i32,
+                        "discriminator": 1_i32
+                    },
+                    "name": "username_discriminator",
+                    "unique": true,
+                    "collation": {
+                        "locale": "en",
+                        "strength": 2_i32
+                    }
                 }
-            },
-            {
-                "key": {
-                    "username": 1_i32,
-                    "discriminator": 1_i32
-                },
-                "name": "username_discriminator",
-                "unique": true,
-                "collation": {
-                    "locale": "en",
-                    "strength": 2_i32
-                }
-            }
-        ]
-    })
+            ]
+        },
+        None,
+    )
     .await
     .expect("Failed to create username index.");
 
-    db.run_command(doc! {
-        "createIndexes": "messages",
-        "indexes": [
-            {
-                "key": {
-                    "content": "text"
+    db.run_command(
+        doc! {
+            "createIndexes": "messages",
+            "indexes": [
+                {
+                    "key": {
+                        "content": "text"
+                    },
+                    "name": "content"
                 },
-                "name": "content"
-            },
-            {
-                "key": {
-                    "channel": 1_i32,
-                    "_id": 1_i32
+                {
+                    "key": {
+                        "channel": 1_i32,
+                        "_id": 1_i32
+                    },
+                    "name": "channel_id_compound"
                 },
-                "name": "channel_id_compound"
-            },
-            {
-                "key": {
-                    "author": 1_i32
+                {
+                    "key": {
+                        "author": 1_i32
+                    },
+                    "name": "author"
                 },
-                "name": "author"
-            },
-            {
-                "key": {
-                    "channel": 1_i32,
-                    "pinned": 1_i32
+                {
+                    "key": {
+                        "channel": 1_i32,
+                        "pinned": 1_i32
+                    },
+                    "name": "channel_pinned_compound"
                 },
-                "name": "channel_pinned_compound"
-            },
-        ]
-    })
+            ]
+        },
+        None,
+    )
     .await
     .expect("Failed to create message index.");
 
-    db.run_command(doc! {
-        "createIndexes": "channel_unreads",
-        "indexes": [
-            {
-                "key": {
-                    "_id.channel": 1_i32,
-                    "_id.user": 1_i32,
+    db.run_command(
+        doc! {
+            "createIndexes": "channel_unreads",
+            "indexes": [
+                {
+                    "key": {
+                        "_id.channel": 1_i32,
+                        "_id.user": 1_i32,
+                    },
+                    "name": "compound_id"
                 },
-                "name": "compound_id"
-            },
-            {
-                "key": {
-                    "_id.user": 1_i32,
-                },
-                "name": "user_id"
-            }
-        ]
-    })
+                {
+                    "key": {
+                        "_id.user": 1_i32,
+                    },
+                    "name": "user_id"
+                }
+            ]
+        },
+        None,
+    )
     .await
     .expect("Failed to create channel_unreads index.");
 
-    db.run_command(doc! {
-        "createIndexes": "server_members",
-        "indexes": [
-            {
-                "key": {
-                    "_id.server": 1_i32,
-                    "_id.user": 1_i32,
+    db.run_command(
+        doc! {
+            "createIndexes": "server_members",
+            "indexes": [
+                {
+                    "key": {
+                        "_id.server": 1_i32,
+                        "_id.user": 1_i32,
+                    },
+                    "name": "compound_id"
                 },
-                "name": "compound_id"
-            },
-            {
-                "key": {
-                    "_id.user": 1_i32,
-                },
-                "name": "user_id"
-            }
-        ]
-    })
+                {
+                    "key": {
+                        "_id.user": 1_i32,
+                    },
+                    "name": "user_id"
+                }
+            ]
+        },
+        None,
+    )
     .await
     .expect("Failed to create server_members index.");
 
-    db.run_command(doc! {
-        "createIndexes": "attachments",
-        "indexes": [
-            {
-                "key": {
-                    "hash": 1_i32
+    db.run_command(
+        doc! {
+            "createIndexes": "attachments",
+            "indexes": [
+                {
+                    "key": {
+                        "hash": 1_i32
+                    },
+                    "name": "hash"
                 },
-                "name": "hash"
-            },
-            {
-                "key": {
-                    "used_for.id": 1_i32
-                },
-                "name": "used_for_id"
-            }
-        ]
-    })
+                {
+                    "key": {
+                        "used_for.id": 1_i32
+                    },
+                    "name": "used_for_id"
+                }
+            ]
+        },
+        None,
+    )
     .await
     .expect("Failed to create attachments index.");
 
-    db.run_command(doc! {
-        "createIndexes": "attachment_hashes",
-        "indexes": [
-            {
-                "key": {
-                    "processed_hash": 1_i32
-                },
-                "name": "processed_hash"
-            }
-        ]
-    })
+    db.run_command(
+        doc! {
+            "createIndexes": "attachment_hashes",
+            "indexes": [
+                {
+                    "key": {
+                        "processed_hash": 1_i32
+                    },
+                    "name": "processed_hash"
+                }
+            ]
+        },
+        None,
+    )
     .await
     .expect("Failed to create attachment_hashes index.");
 
     db.collection("migrations")
-        .insert_one(doc! {
-            "_id": 0_i32,
-            "revision": LATEST_REVISION
-        })
+        .insert_one(
+            doc! {
+                "_id": 0_i32,
+                "revision": LATEST_REVISION
+            },
+            None,
+        )
         .await
         .expect("Failed to save migration info.");
 
-    db.run_command(doc! {
-        "createIndexes": "ratelimit_events",
-        "indexes": [
-            {
-                "key": {
-                    "_id": 1_i32,
-                    "target_id": 1_i32,
-                    "event_type": 1_i32,
-                },
-                "name": "compound_key"
-            }
-        ]
-    })
+    db.run_command(
+        doc! {
+            "createIndexes": "ratelimit_events",
+            "indexes": [
+                {
+                    "key": {
+                        "_id": 1_i32,
+                        "target_id": 1_i32,
+                        "event_type": 1_i32,
+                    },
+                    "name": "compound_key"
+                }
+            ]
+        },
+        None,
+    )
     .await
     .expect("Failed to create ratelimit_events index.");
 

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

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

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

@@ -2,7 +2,6 @@ use revolt_result::Result;
 
 use crate::{Bot, FieldsBot, PartialBot};
 
-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;
 

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::TextChannel { id, server, .. } | Channel::VoiceChannel { id, server, .. } => {
                 Ok(Invite::Server {
                     code,
                     creator: creator.id.clone(),

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

@@ -2,7 +2,6 @@ use revolt_result::Result;
 
 use crate::Invite;
 
-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;
 

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

@@ -24,9 +24,12 @@ impl AbstractChannelInvites for MongoDb {
     async fn fetch_invites_for_server(&self, server_id: &str) -> Result<Vec<Invite>> {
         Ok(self
             .col::<Invite>(COL)
-            .find(doc! {
-                "server": server_id,
-            })
+            .find(
+                doc! {
+                    "server": server_id,
+                },
+                None,
+            )
             .await
             .map_err(|_| create_database_error!("find", COL))?
             .filter_map(|s| async {

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

@@ -2,7 +2,6 @@ use revolt_result::Result;
 
 use crate::ChannelUnread;
 
-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;
 
@@ -27,14 +26,6 @@ pub trait AbstractChannelUnreads: Sync + Send {
         message_ids: &[String],
     ) -> Result<()>;
 
-    /// Add a mention.
-    async fn add_mention_to_many_unreads<'a>(
-        &self,
-        channel_id: &str,
-        user_ids: &[String],
-        message_ids: &[String],
-    ) -> Result<()>;
-
     /// Fetch all unreads with mentions for a user.
     async fn fetch_unread_mentions(&self, user_id: &str) -> Result<Vec<ChannelUnread>>;
 

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

@@ -37,8 +37,6 @@ impl AbstractChannelUnreads for MongoDb {
                         "last_id": message_id
                     }
                 },
-            )
-            .with_options(
                 FindOneAndUpdateOptions::builder()
                     .upsert(true)
                     .return_document(ReturnDocument::After)
@@ -53,12 +51,15 @@ impl AbstractChannelUnreads for MongoDb {
         let current_time = Ulid::new().to_string();
 
         self.col::<Document>(COL)
-            .delete_many(doc! {
-                "_id.channel": {
-                    "$in": channel_ids
+            .delete_many(
+                doc! {
+                    "_id.channel": {
+                        "$in": channel_ids
+                    },
+                    "_id.user": user_id
                 },
-                "_id.user": user_id
-            })
+                None,
+            )
             .await
             .map_err(|_| create_database_error!("delete_many", COL))?;
 
@@ -76,6 +77,7 @@ impl AbstractChannelUnreads for MongoDb {
                         }
                     })
                     .collect::<Vec<Document>>(),
+                None,
             )
             .await
             .map(|_| ())
@@ -102,42 +104,13 @@ impl AbstractChannelUnreads for MongoDb {
                         }
                     }
                 },
+                UpdateOptions::builder().upsert(true).build(),
             )
-            .with_options(UpdateOptions::builder().upsert(true).build())
             .await
             .map(|_| ())
             .map_err(|_| create_database_error!("update_one", COL))
     }
 
-    /// Add a mention to multiple users.
-    async fn add_mention_to_many_unreads<'a>(
-        &self,
-        channel_id: &str,
-        user_ids: &[String],
-        message_ids: &[String],
-    ) -> Result<()> {
-        self.col::<Document>(COL)
-            .update_many(
-                doc! {
-                    "_id.channel": channel_id,
-                    "_id.user": {
-                        "$in": user_ids
-                    },
-                },
-                doc! {
-                    "$push": {
-                        "mentions": {
-                            "$each": message_ids
-                        }
-                    }
-                },
-            )
-            .with_options(UpdateOptions::builder().upsert(true).build())
-            .await
-            .map(|_| ())
-            .map_err(|_| create_database_error!("update_many", COL))
-    }
-
     /// Fetch all channel unreads for a user.
     async fn fetch_unreads(&self, user_id: &str) -> Result<Vec<ChannelUnread>> {
         query!(

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

@@ -78,38 +78,6 @@ impl AbstractChannelUnreads for ReferenceDb {
         Ok(())
     }
 
-    /// Add a mention to multiple users.
-    async fn add_mention_to_many_unreads<'a>(
-        &self,
-        channel_id: &str,
-        user_ids: &[String],
-        message_ids: &[String],
-    ) -> Result<()> {
-        let mut unreads = self.channel_unreads.lock().await;
-
-        for user_id in user_ids {
-            let key = ChannelCompositeKey {
-                channel: channel_id.to_string(),
-                user: user_id.to_string(),
-            };
-
-            if let Some(unread) = unreads.get_mut(&key) {
-                unread.mentions.replace(message_ids.to_vec());
-            } else {
-                unreads.insert(
-                    key.clone(),
-                    ChannelUnread {
-                        id: key,
-                        last_id: None,
-                        mentions: Some(message_ids.to_vec()),
-                    },
-                );
-            }
-        }
-
-        Ok(())
-    }
-
     async fn fetch_unread_mentions(&self, user_id: &str) -> Result<Vec<ChannelUnread>> {
         let unreads = self.channel_unreads.lock().await;
         Ok(unreads

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

@@ -142,7 +142,7 @@ mod tests {
                 ..Default::default()
             };
 
-            webhook.create(&db).await.unwrap();
+            db.insert_webhook(&webhook).await.unwrap();
 
             let mut updated_webhook = webhook.clone();
             updated_webhook

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

@@ -2,7 +2,6 @@ use revolt_result::Result;
 
 use crate::{FieldsWebhook, PartialWebhook, Webhook};
 
-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;
 

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

@@ -24,9 +24,12 @@ impl AbstractWebhooks for MongoDb {
     async fn fetch_webhooks_for_channel(&self, channel_id: &str) -> Result<Vec<Webhook>> {
         Ok(self
             .col::<Webhook>(COL)
-            .find(doc! {
-                "channel_id": channel_id,
-            })
+            .find(
+                doc! {
+                    "channel_id": channel_id,
+                },
+                None,
+            )
             .await
             .map_err(|_| create_database_error!("find", COL))?
             .filter_map(|s| async {

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

@@ -1,5 +1,4 @@
-#![allow(deprecated)]
-use std::{borrow::Cow, collections::HashMap};
+use std::collections::HashMap;
 
 use revolt_config::config;
 use revolt_models::v0::{self, MessageAuthor};
@@ -9,12 +8,10 @@ use serde::{Deserialize, Serialize};
 use ulid::Ulid;
 
 use crate::{
-    events::client::EventV1, Database, File, PartialServer, Server, SystemMessage, User, AMQP,
+    events::client::EventV1, tasks::ack::AckEvent, Database, File, IntoDocumentPath, PartialServer,
+    Server, SystemMessage, User, AMQP,
 };
 
-#[cfg(feature = "mongodb")]
-use crate::IntoDocumentPath;
-
 auto_derived!(
     #[serde(tag = "channel_type")]
     pub enum Channel {
@@ -106,18 +103,38 @@ auto_derived!(
             /// Whether this channel is marked as not safe for work
             #[serde(skip_serializing_if = "crate::if_false", default)]
             nsfw: bool,
-
-            /// Voice Information for when this channel is also a voice channel
-            #[serde(skip_serializing_if = "Option::is_none")]
-            voice: Option<VoiceInformation>,
         },
-    }
+        /// Voice channel belonging to a server
+        VoiceChannel {
+            /// Unique Id
+            #[serde(rename = "_id")]
+            id: String,
+            /// Id of the server this channel belongs to
+            server: String,
 
-    #[derive(Default)]
-    pub struct VoiceInformation {
-        /// Maximium amount of users allowed in the voice channel at once
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub max_users: Option<usize>,
+            /// Display name of the channel
+            name: String,
+            #[serde(skip_serializing_if = "Option::is_none")]
+            /// Channel description
+            description: Option<String>,
+            /// Custom icon attachment
+            #[serde(skip_serializing_if = "Option::is_none")]
+            icon: Option<File>,
+
+            /// Default permissions assigned to users in this channel
+            #[serde(skip_serializing_if = "Option::is_none")]
+            default_permissions: Option<OverrideField>,
+            /// Permissions assigned based on role to this channel
+            #[serde(
+                default = "HashMap::<String, OverrideField>::new",
+                skip_serializing_if = "HashMap::<String, OverrideField>::is_empty"
+            )]
+            role_permissions: HashMap<String, OverrideField>,
+
+            /// Whether this channel is marked as not safe for work
+            #[serde(skip_serializing_if = "crate::if_false", default)]
+            nsfw: bool,
+        },
     }
 );
 
@@ -144,8 +161,6 @@ auto_derived!(
         pub default_permissions: Option<OverrideField>,
         #[serde(skip_serializing_if = "Option::is_none")]
         pub last_message_id: Option<String>,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub voice: Option<VoiceInformation>,
     }
 
     /// Optional fields on channel object
@@ -153,7 +168,6 @@ auto_derived!(
         Description,
         Icon,
         DefaultPermissions,
-        Voice,
     }
 );
 
@@ -205,19 +219,16 @@ impl Channel {
                 default_permissions: None,
                 role_permissions: HashMap::new(),
                 nsfw: data.nsfw.unwrap_or(false),
-                voice: data.voice.map(|voice| voice.into()),
             },
-            v0::LegacyServerChannelType::Voice => Channel::TextChannel {
+            v0::LegacyServerChannelType::Voice => Channel::VoiceChannel {
                 id: id.clone(),
                 server: server.id.to_owned(),
                 name: data.name,
                 description: data.description,
                 icon: None,
-                last_message_id: None,
                 default_permissions: None,
                 role_permissions: HashMap::new(),
                 nsfw: data.nsfw.unwrap_or(false),
-                voice: Some(data.voice.unwrap_or_default().into()),
             },
         };
 
@@ -258,24 +269,16 @@ impl Channel {
             }));
         }
 
-        let id = ulid::Ulid::new().to_string();
-
-        let icon = if let Some(icon_id) = data.icon {
-            Some(File::use_channel_icon(db, &icon_id, &id, &owner_id).await?)
-        } else {
-            None
-        };
-
         let recipients = data.users.into_iter().collect::<Vec<String>>();
         let channel = Channel::Group {
-            id,
+            id: ulid::Ulid::new().to_string(),
 
             name: data.name,
             owner: owner_id,
             description: data.description,
             recipients: recipients.clone(),
 
-            icon,
+            icon: None,
             last_message_id: None,
 
             permissions: None,
@@ -317,10 +320,13 @@ impl Channel {
 
             db.insert_channel(&channel).await?;
 
-            if let Channel::DirectMessage { .. } = &channel {
-                let event = EventV1::ChannelCreate(channel.clone().into());
-                event.clone().private(user_a.id.clone()).await;
-                event.private(user_b.id.clone()).await;
+            match &channel {
+                Channel::DirectMessage { .. } => {
+                    let event = EventV1::ChannelCreate(channel.clone().into());
+                    event.clone().private(user_a.id.clone()).await;
+                    event.private(user_b.id.clone()).await;
+                }
+                _ => {}
             };
 
             Ok(channel)
@@ -418,28 +424,8 @@ impl Channel {
             Channel::DirectMessage { id, .. }
             | Channel::Group { id, .. }
             | Channel::SavedMessages { id, .. }
-            | Channel::TextChannel { id, .. } => id,
-        }
-    }
-
-    /// Clone this channel's server id
-    pub fn server(&self) -> Option<&str> {
-        match self {
-            Channel::TextChannel { server, .. } => Some(server),
-            _ => None,
-        }
-    }
-
-    /// Gets this channel's voice information
-    pub fn voice(&self) -> Option<Cow<VoiceInformation>> {
-        match self {
-            Self::DirectMessage { .. } | Self::Group { .. } => {
-                Some(Cow::Owned(VoiceInformation::default()))
-            }
-            Self::TextChannel {
-                voice: Some(voice), ..
-            } => Some(Cow::Borrowed(voice)),
-            _ => None,
+            | Channel::TextChannel { id, .. }
+            | Channel::VoiceChannel { id, .. } => id,
         }
     }
 
@@ -456,6 +442,12 @@ impl Channel {
                 server,
                 role_permissions,
                 ..
+            }
+            | Channel::VoiceChannel {
+                id,
+                server,
+                role_permissions,
+                ..
             } => {
                 db.set_channel_role_permission(id, role_id, permissions)
                     .await?;
@@ -502,7 +494,7 @@ impl Channel {
             clear: remove.into_iter().map(|v| v.into()).collect(),
         }
         .p(match self {
-            Self::TextChannel { server, .. } => server.clone(),
+            Self::TextChannel { server, .. } | Self::VoiceChannel { server, .. } => server.clone(),
             _ => id,
         })
         .await;
@@ -514,13 +506,17 @@ impl Channel {
     pub fn remove_field(&mut self, field: &FieldsChannel) {
         match field {
             FieldsChannel::Description => match self {
-                Self::Group { description, .. } | Self::TextChannel { description, .. } => {
+                Self::Group { description, .. }
+                | Self::TextChannel { description, .. }
+                | Self::VoiceChannel { description, .. } => {
                     description.take();
                 }
                 _ => {}
             },
             FieldsChannel::Icon => match self {
-                Self::Group { icon, .. } | Self::TextChannel { icon, .. } => {
+                Self::Group { icon, .. }
+                | Self::TextChannel { icon, .. }
+                | Self::VoiceChannel { icon, .. } => {
                     icon.take();
                 }
                 _ => {}
@@ -529,17 +525,15 @@ impl Channel {
                 Self::TextChannel {
                     default_permissions,
                     ..
+                }
+                | Self::VoiceChannel {
+                    default_permissions,
+                    ..
                 } => {
                     default_permissions.take();
                 }
                 _ => {}
             },
-            FieldsChannel::Voice => match self {
-                Self::TextChannel { voice, .. } => {
-                    voice.take();
-                }
-                _ => {}
-            },
         }
     }
 
@@ -551,7 +545,6 @@ impl Channel {
     }
 
     /// Apply partial channel to channel
-    #[allow(deprecated)]
     pub fn apply_options(&mut self, partial: PartialChannel) {
         match self {
             Self::SavedMessages { .. } => {}
@@ -600,7 +593,15 @@ impl Channel {
                 nsfw,
                 default_permissions,
                 role_permissions,
-                voice,
+                ..
+            }
+            | Self::VoiceChannel {
+                name,
+                description,
+                icon,
+                nsfw,
+                default_permissions,
+                role_permissions,
                 ..
             } => {
                 if let Some(v) = partial.name {
@@ -626,10 +627,6 @@ impl Channel {
                 if let Some(v) = partial.default_permissions {
                     default_permissions.replace(v);
                 }
-
-                if let Some(v) = partial.voice {
-                    voice.replace(v);
-                }
             }
         }
     }
@@ -644,11 +641,10 @@ impl Channel {
         .private(user.to_string())
         .await;
 
-        #[cfg(feature = "tasks")]
         crate::tasks::ack::queue_ack(
             self.id().to_string(),
             user.to_string(),
-            crate::tasks::ack::AckEvent::AckMessage {
+            AckEvent::AckMessage {
                 id: message.to_string(),
             },
         )
@@ -765,14 +761,12 @@ impl Channel {
     }
 }
 
-#[cfg(feature = "mongodb")]
 impl IntoDocumentPath for FieldsChannel {
     fn as_path(&self) -> Option<&'static str> {
         Some(match self {
             FieldsChannel::Description => "description",
             FieldsChannel::Icon => "icon",
             FieldsChannel::DefaultPermissions => "default_permissions",
-            FieldsChannel::Voice => "voice",
         })
     }
 }

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

@@ -1,7 +1,5 @@
 use crate::{revolt_result::Result, Channel, FieldsChannel, PartialChannel};
 use revolt_permissions::OverrideField;
-
-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;
 

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

@@ -23,11 +23,14 @@ impl AbstractChannels for MongoDb {
     async fn fetch_channels<'a>(&self, ids: &'a [String]) -> Result<Vec<Channel>> {
         Ok(self
             .col::<Channel>(COL)
-            .find(doc! {
-                "_id": {
-                    "$in": ids
-                }
-            })
+            .find(
+                doc! {
+                    "_id": {
+                        "$in": ids
+                    }
+                },
+                None,
+            )
             .await
             .map_err(|_| create_database_error!("fetch", "channels"))?
             .filter_map(|s| async {
@@ -116,6 +119,7 @@ impl AbstractChannels for MongoDb {
                         "recipients": user
                     }
                 },
+                None,
             )
             .await
             .map(|_| ())
@@ -137,6 +141,7 @@ impl AbstractChannels for MongoDb {
                     "role_permissions.".to_owned() + role: permissions
                 }
                 },
+                None,
             )
             .await
             .map(|_| ())
@@ -174,6 +179,7 @@ impl AbstractChannels for MongoDb {
                         "recipients": user
                     }
                 },
+                None,
             )
             .await
             .map(|_| ())
@@ -184,7 +190,7 @@ impl AbstractChannels for MongoDb {
     async fn delete_channel(&self, channel: &Channel) -> Result<()> {
         let id = channel.id().to_string();
         let server_id = match channel {
-            Channel::TextChannel { server, .. } => {
+            Channel::TextChannel { server, .. } | Channel::VoiceChannel { server, .. } => {
                 Some(server)
             }
             _ => None,
@@ -247,6 +253,7 @@ impl AbstractChannels for MongoDb {
                         "_id": server.id
                     },
                     update,
+                    None,
                 )
                 .await
                 .map_err(|_| create_database_error!("update_one", "servers"))?;
@@ -267,17 +274,23 @@ impl MongoDb {
     pub async fn delete_associated_channel_objects(&self, id: Bson) -> Result<()> {
         // Delete all invites to these channels.
         self.col::<Document>("channel_invites")
-            .delete_many(doc! {
-                "channel": &id
-            })
+            .delete_many(
+                doc! {
+                    "channel": &id
+                },
+                None,
+            )
             .await
             .map_err(|_| create_database_error!("delete_many", "channel_invites"))?;
 
         // Delete unread message objects on channels.
         self.col::<Document>("channel_unreads")
-            .delete_many(doc! {
-                "_id.channel": &id
-            })
+            .delete_many(
+                doc! {
+                    "_id.channel": &id
+                },
+                None,
+            )
             .await
             .map_err(|_| create_database_error!("delete_many", "channel_unreads"))
             .map(|_| ())?;
@@ -286,9 +299,12 @@ impl MongoDb {
 
         // Delete all webhooks on this channel.
         self.col::<Document>("webhooks")
-            .delete_many(doc! {
-                "channel": &id
-            })
+            .delete_many(
+                doc! {
+                    "channel": &id
+                },
+                None,
+            )
             .await
             .map_err(|_| create_database_error!("delete_many", "webhooks"))
             .map(|_| ())

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

@@ -94,6 +94,9 @@ impl AbstractChannels for ReferenceDb {
             match &mut channel {
                 Channel::TextChannel {
                     role_permissions, ..
+                }
+                | Channel::VoiceChannel {
+                    role_permissions, ..
                 } => {
                     if role_permissions.get(role_id).is_some() {
                         role_permissions.remove(role_id);

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

@@ -2,7 +2,6 @@ use revolt_result::Result;
 
 use crate::Emoji;
 
-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;
 

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

@@ -60,6 +60,7 @@ impl AbstractEmojis for MongoDb {
                         }
                     }
                 },
+                None,
             )
             .await
             .map(|_| ())

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

@@ -28,7 +28,7 @@ auto_derived_partial!(
         /// Size of this file (in bytes)
         pub size: isize,
     },
-    "PartialFileHash"
+    "PartialFile"
 );
 
 auto_derived!(

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

@@ -2,7 +2,6 @@ use revolt_result::Result;
 
 use crate::FileHash;
 
-#[cfg(feature = "mongodb")]
 mod mongodb;
 mod reference;