fix: add additional checks to group members

fix: separate privileged check when editing server

.dockerignore

@@ -1,3 +1,4 @@
+Dockerfile
 target
 .mongo
 .env

.github/FUNDING.yml

@@ -1,2 +0,0 @@
-ko_fi: insertish
-custom: https://insrt.uk/donate

.github/workflows/cla.yml

@@ -0,0 +1,36 @@
+name: "CLA Assistant"
+on:
+  issue_comment:
+    types: [created]
+  pull_request_target:
+    types: [opened,closed,synchronize]
+
+jobs:
+  CLAssistant:
+    runs-on: ubuntu-latest
+    steps:
+      - name: "CLA Assistant"
+        if: (github.event.comment.body == 'recheck' || github.event.comment.body == 'I have read the CLA Document and I hereby sign the CLA') || github.event_name == 'pull_request_target'
+        # Beta Release
+        uses: cla-assistant/github-action@v2.1.3-beta
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          # the below token should have repo scope and must be manually added by you in the repository's secret
+          PERSONAL_ACCESS_TOKEN : ${{ secrets.PAT }}
+        with:
+          path-to-signatures: 'signatures/version1/cla.json'
+          path-to-document: 'https://github.com/revoltchat/cla/blob/master/CLA.md' # e.g. a CLA or a DCO document
+          # branch should not be protected
+          branch: 'master'
+          allowlist: insertish,bot*
+
+         #below are the optional inputs - If the optional inputs are not given, then default values will be taken
+          remote-organization-name: revoltchat
+          remote-repository-name: cla
+          create-file-commit-message: 'cla(create): creating file for storing CLA Signatures'
+          signed-commit-message: 'cla(sign): $contributorName has signed the CLA in #$pullRequestNo'
+          #custom-notsigned-prcomment: 'pull request comment with Introductory message to ask new contributors to sign'
+          #custom-pr-sign-comment: 'The signature to be committed in order to sign the CLA'
+          #custom-allsigned-prcomment: 'pull request comment when all contributors has signed, defaults to **CLA Assistant Lite bot** All Contributors have signed the CLA.'
+          #lock-pullrequest-aftermerge: false - if you don't want this bot to automatically lock the pull request after merging (default - true)
+          #use-dco-flag: true - If you are using DCO instead of CLA

.github/workflows/docker.yaml

@@ -0,0 +1,116 @@
+name: Docker Test & Publish
+
+on:
+  push:
+    branches:
+      - "master"
+    tags:
+      - "*"
+    paths-ignore:
+      - ".github/**"
+      - "!.github/workflows/docker.yml"
+      - ".vscode/**"
+      - ".gitignore"
+      - "LICENSE"
+      - "README"
+  pull_request:
+    branches:
+      - "master"
+    paths:
+      - "Dockerfile"
+  workflow_dispatch:
+
+jobs:
+  base:
+    runs-on: ubuntu-latest
+    name: Build base image (amd64)
+    steps:
+      # Configure build environment
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+
+      # Authenticate with GHCR
+      - name: Login to Github Container Registry
+        uses: docker/login-action@v1
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      # Build all projects and cache
+      - name: Build Base Image
+        uses: docker/build-push-action@v3
+        with:
+          context: .
+          push: true
+          tags: ghcr.io/revoltchat/base:latest
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+  publish_amd64:
+    needs: [base]
+    runs-on: ubuntu-latest
+    if: github.event_name != 'pull_request'
+    strategy:
+      matrix:
+        project: [delta, bonfire]
+    name: Build ${{ matrix.project }} image (amd64)
+    steps:
+      # Configure build environment
+      - name: Checkout
+        uses: actions/checkout@v2
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v2
+
+      # Authenticate with Docker Hub and GHCR
+      - name: Login to DockerHub
+        uses: docker/login-action@v2
+        with:
+          username: ${{ secrets.DOCKERHUB_USERNAME }}
+          password: ${{ secrets.DOCKERHUB_TOKEN }}
+      - name: Login to Github Container Registry
+        uses: docker/login-action@v1
+        with:
+          registry: ghcr.io
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+
+      # Resolve the correct project
+      - uses: kanga333/variable-mapper@master
+        id: export
+        with:
+          key: "${{ matrix.project }}"
+          map: |
+            {
+              "delta": {
+                "path": "crates/delta",
+                "tag": "revoltchat/server"
+              },
+              "bonfire": {
+                "path": "crates/bonfire",
+                "tag": "revoltchat/bonfire"
+              }
+            }
+          export_to: output
+
+      # Configure metadata
+      - name: Docker meta
+        id: meta
+        uses: docker/metadata-action@v3
+        with:
+          images: ${{ steps.export.outputs.tag }}, ghcr.io/${{ steps.export.outputs.tag }}
+
+      # Build crate image
+      - name: Publish
+        uses: docker/build-push-action@v3
+        with:
+          context: .
+          push: true
+          platforms: linux/amd64
+          file: ${{ steps.export.outputs.path }}/Dockerfile
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max

.github/workflows/rust.yaml

@@ -1,10 +1,10 @@
-name: Rust build and test
+name: Rust build, test, and generate specification
 
 on:
   push:
-    branches: [ master ]
+    branches: [master]
   pull_request:
-    branches: [ master ]
+    branches: [master]
 
 env:
   CARGO_TERM_COLOR: always
@@ -15,19 +15,62 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - name: Install latest nightly
+      - name: Install latest stable
         uses: actions-rs/toolchain@v1
         with:
-            toolchain: nightly
-            override: true
-            components: rustfmt, clippy
+          toolchain: stable
+          override: true
+          components: rustfmt, clippy
 
       - name: Run cargo build
         uses: actions-rs/cargo@v1
         with:
           command: build
-      
+
       - name: Run cargo test
         uses: actions-rs/cargo@v1
         with:
           command: test
+
+      - name: Copy .env.example
+        if: github.event_name != 'pull_request'
+        run: |
+          cp .env.example .env
+
+      - name: Run services in background
+        if: github.event_name != 'pull_request'
+        run: |
+          docker-compose -f docker-compose.db.yml up -d
+
+      - name: Start API in background
+        if: github.event_name != 'pull_request'
+        run: |
+          cargo run --bin revolt-delta &
+
+      - name: Wait for API to go up
+        if: github.event_name != 'pull_request'
+        uses: nev7n/wait_for_response@v1
+        with:
+          url: "http://localhost:8000/"
+
+      - name: Checkout API repository
+        if: github.event_name != 'pull_request'
+        uses: actions/checkout@v3
+        with:
+          repository: revoltchat/api
+          path: api
+          token: ${{ secrets.PAT }}
+
+      - name: Download OpenAPI specification
+        if: github.event_name != 'pull_request'
+        run: curl http://localhost:8000/openapi.json -o api/OpenAPI.json
+
+      - name: Commit changes
+        if: github.event_name != 'pull_request'
+        uses: EndBug/add-and-commit@v4
+        with:
+          cwd: "api"
+          add: "*.json"
+          author_name: Revolt CI
+          author_email: revolt-ci@users.noreply.github.com
+          message: "chore: generate OpenAPI specification"

.github/workflows/triage_issue.yml

@@ -15,22 +15,27 @@ jobs:
           gh api graphql -f query='
             query {
               organization(login: "revoltchat"){
-                projectNext(number: 3) {
+                projectV2(number: 3) {
                   id
                   fields(first:20) {
                     nodes {
-                      id
-                      name
-                      settings
+                      ... on ProjectV2SingleSelectField {
+                        id
+                        name
+                        options {
+                          id
+                          name
+                        }
+                      }
                     }
                   }
                 }
               }
             }' > project_data.json
 
-          echo 'PROJECT_ID='$(jq '.data.organization.projectNext.id' project_data.json) >> $GITHUB_ENV
-          echo 'STATUS_FIELD_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") | .id' project_data.json) >> $GITHUB_ENV
-          echo 'TODO_OPTION_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") |.settings | fromjson.options[] | select(.name=="Todo") |.id' project_data.json) >> $GITHUB_ENV
+          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:
@@ -39,11 +44,11 @@ jobs:
         run: |
           item_id="$( gh api graphql -f query='
             mutation($project:ID!, $issue:ID!) {
-              addProjectNextItem(input: {projectId: $project, contentId: $issue}) {
-                projectNextItem {
+              addProjectV2ItemById(input: {projectId: $project, contentId: $issue}) {
+                item {
                   id
                 }
               }
-            }' -f project=$PROJECT_ID -f issue=$ISSUE_ID --jq '.data.addProjectNextItem.projectNextItem.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

@@ -15,22 +15,27 @@ jobs:
           gh api graphql -f query='
             query {
               organization(login: "revoltchat"){
-                projectNext(number: 3) {
+                projectV2(number: 3) {
                   id
                   fields(first:20) {
                     nodes {
-                      id
-                      name
-                      settings
+                      ... on ProjectV2SingleSelectField {
+                        id
+                        name
+                        options {
+                          id
+                          name
+                        }
+                      }
                     }
                   }
                 }
               }
             }' > project_data.json
 
-          echo 'PROJECT_ID='$(jq '.data.organization.projectNext.id' project_data.json) >> $GITHUB_ENV
-          echo 'STATUS_FIELD_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") | .id' project_data.json) >> $GITHUB_ENV
-          echo 'INCOMING_OPTION_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") |.settings | fromjson.options[] | select(.name=="Incoming PRs") |.id' project_data.json) >> $GITHUB_ENV
+          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=="Incoming PRs") |.id' project_data.json) >> $GITHUB_ENV
 
       - name: Add PR to project
         env:
@@ -39,13 +44,13 @@ jobs:
         run: |
           item_id="$( gh api graphql -f query='
             mutation($project:ID!, $pr:ID!) {
-              addProjectNextItem(input: {projectId: $project, contentId: $pr}) {
-                projectNextItem {
+              addProjectV2ItemById(input: {projectId: $project, contentId: $pr}) {
+                item {
                   id
                 }
               }
-            }' -f project=$PROJECT_ID -f pr=$PR_ID --jq '.data.addProjectNextItem.projectNextItem.id')"
-          
+            }' -f project=$PROJECT_ID -f pr=$PR_ID --jq '.data.addProjectV2ItemById.item.id')"
+
           echo 'ITEM_ID='$item_id >> $GITHUB_ENV
 
       - name: Set fields
@@ -59,14 +64,16 @@ jobs:
               $status_field: ID!
               $status_value: String!
             ) {
-              set_status: updateProjectNextItemField(input: {
+              set_status: updateProjectV2ItemFieldValue(input: {
                 projectId: $project
                 itemId: $item
                 fieldId: $status_field
-                value: $status_value
+                value: {
+                  singleSelectOptionId: $status_value
+                }
               }) {
-                projectNextItem {
+                projectV2Item {
                   id
-                  }
+                }
               }
             }' -f project=$PROJECT_ID -f item=$ITEM_ID -f status_field=$STATUS_FIELD_ID -f status_value=${{ env.INCOMING_OPTION_ID }} --silent

.gitignore

@@ -1,2 +1,6 @@
 Rocket.toml
 target
+.data
+.env
+
+.vercel

Cargo.toml

@@ -1,2 +1,2 @@
 [workspace]
-members = ["crates/bonfire", "crates/delta", "crates/quark", "crates/revcord/*"]
+members = ["crates/*"]

Dockerfile

@@ -0,0 +1,12 @@
+# Build Stage
+FROM rustlang/rust:nightly-slim AS builder
+USER 0:0
+WORKDIR /home/rust/src
+
+# Install build requirements
+RUN apt-get update && apt-get install -y libssl-dev pkg-config
+
+# Build all crates
+COPY Cargo.toml Cargo.lock ./
+COPY crates ./crates
+RUN cargo build --locked --release

README.md

@@ -2,14 +2,14 @@
 
 This is a monorepo for the Revolt backend.
 
-| Crate            | Description                          |
-| ---------------- | ------------------------------------ |
-| `delta`          | REST API server                      |
-| `bonfire`        | WebSocket events server              |
-| `quark`          | Models and logic                     |
-| `revcord/api`    | Discord REST translation layer       |
-| `revcord/ws`     | Discord gateway translation layer    |
-| `revcord/models` | Discord models and quark translation |
+| Crate            | Path                                           | Description                          |
+| ---------------- | ---------------------------------------------- | ------------------------------------ |
+| `delta`          | [crates/delta](crates/delta)                   | REST API server                      |
+| `bonfire`        | [crates/bonfire](crates/bonfire)               | WebSocket events server              |
+| `quark`          | [crates/quark](crates/quark)                   | Models and logic                     |
+<!--| `revcord/api`    | [crates/revcord/api](crates/revcord/api)       | Discord REST translation layer       |
+| `revcord/ws`     | [crates/revcord/ws](crates/revcord/ws)         | Discord gateway translation layer    |
+| `revcord/models` | [crates/revcord/models](crates/revcord/models) | Discord models and quark translation |-->
 
 Note: `january`, `autumn`, and `vortex` are yet to be moved into this monorepo.
 

crates/bonfire/.github/FUNDING.yml

@@ -1,2 +0,0 @@
-ko_fi: insertish
-custom: https://insrt.uk/donate

crates/bonfire/.github/workflows/docker.yml

@@ -1,98 +0,0 @@
-name: Docker
-
-on:
-  push:
-    branches:
-      - "master"
-    tags:
-      - "*"
-    paths-ignore:
-      - ".github/**"
-      - "!.github/workflows/docker.yml"
-      - ".vscode/**"
-      - ".gitignore"
-      - ".gitlab-ci.yml"
-      - "LICENSE"
-      - "README"
-  pull_request:
-    branches:
-      - "master"
-    paths:
-      - "Dockerfile"
-  workflow_dispatch:
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        architecture: [linux/amd64]
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-        with:
-          submodules: "recursive"
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v1
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
-      - name: Cache Docker layers
-        uses: actions/cache@v2
-        with:
-          path: /tmp/.buildx-cache/${{ matrix.architecture }}
-          key: ${{ runner.os }}-buildx-${{ matrix.architecture }}-${{ github.sha }}
-      - name: Build
-        uses: docker/build-push-action@v2
-        with:
-          context: .
-          platforms: ${{ matrix.architecture }}
-          cache-from: type=local,src=/tmp/.buildx-cache/${{ matrix.architecture }}
-          cache-to: type=local,dest=/tmp/.buildx-cache-new/${{ matrix.architecture }},mode=max
-      - name: Move cache
-        run: |
-          rm -rf /tmp/.buildx-cache/${{ matrix.architecture }}
-          mv /tmp/.buildx-cache-new/${{ matrix.architecture }} /tmp/.buildx-cache/${{ matrix.architecture }}
-
-  publish_amd64:
-    needs: [test]
-    runs-on: ubuntu-latest
-    if: github.event_name != 'pull_request'
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v2
-        with:
-          submodules: "recursive"
-      - name: Set up QEMU
-        uses: docker/setup-qemu-action@v1
-      - name: Set up Docker Buildx
-        uses: docker/setup-buildx-action@v1
-      - name: Cache amd64 Docker layers
-        uses: actions/cache@v2
-        with:
-          path: /tmp/.buildx-cache/linux/amd64
-          key: ${{ runner.os }}-buildx-linux/amd64-${{ github.sha }}
-      - name: Docker meta
-        id: meta
-        uses: docker/metadata-action@v3
-        with:
-          images: ghcr.io/revoltchat/bonfire
-      - name: Login to Github Container Registry
-        uses: docker/login-action@v1
-        with:
-          registry: ghcr.io
-          username: ${{ github.actor }}
-          password: ${{ secrets.GITHUB_TOKEN }}
-      - name: Build and publish
-        uses: docker/build-push-action@v2
-        with:
-          context: .
-          push: true
-          platforms: linux/amd64
-          tags: ${{ steps.meta.outputs.tags }}
-          labels: ${{ steps.meta.outputs.labels }}
-          cache-from: type=local,src=/tmp/.buildx-cache/linux/amd64
-          cache-to: type=local,dest=/tmp/.buildx-cache-new,mode=max
-      - name: Move cache
-        run: |
-          rm -rf /tmp/.buildx-cache
-          mv /tmp/.buildx-cache-new /tmp/.buildx-cache

crates/bonfire/.github/workflows/rust.yaml

@@ -1,33 +0,0 @@
-name: Rust build and test
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  check:
-    name: Rust project
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install latest nightly
-        uses: actions-rs/toolchain@v1
-        with:
-            toolchain: nightly
-            override: true
-            components: rustfmt, clippy
-
-      - name: Run cargo build
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-      
-      - name: Run cargo test
-        uses: actions-rs/cargo@v1
-        with:
-          command: test

crates/bonfire/.github/workflows/triage_issue.yml

@@ -1,49 +0,0 @@
-name: Add Issue to Board
-
-on:
-  issues:
-    types: [opened]
-
-jobs:
-  track_issue:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get project data
-        env:
-          GITHUB_TOKEN: ${{ secrets.PAT }}
-        run: |
-          gh api graphql -f query='
-            query {
-              organization(login: "revoltchat"){
-                projectNext(number: 3) {
-                  id
-                  fields(first:20) {
-                    nodes {
-                      id
-                      name
-                      settings
-                    }
-                  }
-                }
-              }
-            }' > project_data.json
-
-          echo 'PROJECT_ID='$(jq '.data.organization.projectNext.id' project_data.json) >> $GITHUB_ENV
-          echo 'STATUS_FIELD_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") | .id' project_data.json) >> $GITHUB_ENV
-          echo 'TODO_OPTION_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") |.settings | fromjson.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!) {
-              addProjectNextItem(input: {projectId: $project, contentId: $issue}) {
-                projectNextItem {
-                  id
-                }
-              }
-            }' -f project=$PROJECT_ID -f issue=$ISSUE_ID --jq '.data.addProjectNextItem.projectNextItem.id')"
-          
-          echo 'ITEM_ID='$item_id >> $GITHUB_ENV

crates/bonfire/.github/workflows/triage_pr.yml

@@ -1,72 +0,0 @@
-name: Add PR to Board
-
-on:
-  pull_request_target:
-    types: [opened, synchronize, ready_for_review, review_requested]
-
-jobs:
-  track_pr:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get project data
-        env:
-          GITHUB_TOKEN: ${{ secrets.PAT }}
-        run: |
-          gh api graphql -f query='
-            query {
-              organization(login: "revoltchat"){
-                projectNext(number: 3) {
-                  id
-                  fields(first:20) {
-                    nodes {
-                      id
-                      name
-                      settings
-                    }
-                  }
-                }
-              }
-            }' > project_data.json
-
-          echo 'PROJECT_ID='$(jq '.data.organization.projectNext.id' project_data.json) >> $GITHUB_ENV
-          echo 'STATUS_FIELD_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") | .id' project_data.json) >> $GITHUB_ENV
-          echo 'INCOMING_OPTION_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") |.settings | fromjson.options[] | select(.name=="Incoming PRs") |.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!) {
-              addProjectNextItem(input: {projectId: $project, contentId: $pr}) {
-                projectNextItem {
-                  id
-                }
-              }
-            }' -f project=$PROJECT_ID -f pr=$PR_ID --jq '.data.addProjectNextItem.projectNextItem.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: updateProjectNextItemField(input: {
-                projectId: $project
-                itemId: $item
-                fieldId: $status_field
-                value: $status_value
-              }) {
-                projectNextItem {
-                  id
-                  }
-              }
-            }' -f project=$PROJECT_ID -f item=$ITEM_ID -f status_field=$STATUS_FIELD_ID -f status_value=${{ env.INCOMING_OPTION_ID }} --silent

crates/bonfire/Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "revolt-bonfire"
-version = "1.0.6-patch.2"
+version = "0.5.17"
+license = "AGPL-3.0-or-later"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

crates/bonfire/Dockerfile

@@ -1,19 +1,10 @@
 # Build Stage
-FROM rustlang/rust:nightly-slim AS builder
-USER 0:0
-WORKDIR /home/rust/src
-
-RUN USER=root cargo new --bin bonfire
-WORKDIR /home/rust/src/bonfire
-RUN apt-get update && apt-get install -y libssl-dev pkg-config
-
-COPY Cargo.toml Cargo.lock ./
-COPY src ./src
-RUN cargo install --locked --path .
+FROM ghcr.io/revoltchat/base:latest AS builder
+RUN cargo install --locked --path crates/bonfire
 
 # Bundle Stage
 FROM debian:buster-slim
 RUN apt-get update && apt-get install -y ca-certificates
-COPY --from=builder /usr/local/cargo/bin/bonfire ./
+COPY --from=builder /usr/local/cargo/bin/revolt-bonfire ./
 EXPOSE 9000
-CMD ["./bonfire"]
+CMD ["./revolt-bonfire"]

crates/bonfire/LICENSE

@@ -1,661 +0,0 @@
-                    GNU AFFERO GENERAL PUBLIC LICENSE
-                       Version 3, 19 November 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU Affero General Public License is a free, copyleft license for
-software and other kinds of works, specifically designed to ensure
-cooperation with the community in the case of network server software.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-our General Public Licenses are intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  Developers that use our General Public Licenses protect your rights
-with two steps: (1) assert copyright on the software, and (2) offer
-you this License which gives you legal permission to copy, distribute
-and/or modify the software.
-
-  A secondary benefit of defending all users' freedom is that
-improvements made in alternate versions of the program, if they
-receive widespread use, become available for other developers to
-incorporate.  Many developers of free software are heartened and
-encouraged by the resulting cooperation.  However, in the case of
-software used on network servers, this result may fail to come about.
-The GNU General Public License permits making a modified version and
-letting the public access it on a server without ever releasing its
-source code to the public.
-
-  The GNU Affero General Public License is designed specifically to
-ensure that, in such cases, the modified source code becomes available
-to the community.  It requires the operator of a network server to
-provide the source code of the modified version running there to the
-users of that server.  Therefore, public use of a modified version, on
-a publicly accessible server, gives the public access to the source
-code of the modified version.
-
-  An older license, called the Affero General Public License and
-published by Affero, was designed to accomplish similar goals.  This is
-a different license, not a version of the Affero GPL, but Affero has
-released a new version of the Affero GPL which permits relicensing under
-this license.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU Affero General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Remote Network Interaction; Use with the GNU General Public License.
-
-  Notwithstanding any other provision of this License, if you modify the
-Program, your modified version must prominently offer all users
-interacting with it remotely through a computer network (if your version
-supports such interaction) an opportunity to receive the Corresponding
-Source of your version by providing access to the Corresponding Source
-from a network server at no charge, through some standard or customary
-means of facilitating copying of software.  This Corresponding Source
-shall include the Corresponding Source for any work covered by version 3
-of the GNU General Public License that is incorporated pursuant to the
-following paragraph.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the work with which it is combined will remain governed by version
-3 of the GNU General Public License.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU Affero General Public License from time to time.  Such new versions
-will be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU Affero General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU Affero General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU Affero General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    Revolt Bonfire
-    Copyright (C) 2022 Pawel Makles
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published
-    by the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If your software can interact with users remotely through a computer
-network, you should also make sure that it provides a way for users to
-get its source.  For example, if your program is a web application, its
-interface could display a "Source" link that leads users to an archive
-of the code.  There are many ways you could offer source, and different
-solutions will be better for different programs; see section 13 for the
-specific requirements.
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU AGPL, see
-<https://www.gnu.org/licenses/>.

crates/bonfire/LICENSE

@@ -0,0 +1 @@
+../../LICENSE

crates/bonfire/src/main.rs

@@ -14,7 +14,7 @@ mod websocket;
 #[async_std::main]
 async fn main() {
     // Configure requirements for Bonfire.
-    let _guard = revolt_quark::setup_logging();
+    revolt_quark::configure!();
     database::connect().await;
 
     // Clean up the current region information.

crates/delta/Cargo.toml

@@ -1,6 +1,7 @@
 [package]
 name = "revolt-delta"
-version = "0.5.3-5-patch.2"
+version = "0.5.17"
+license = "AGPL-3.0-or-later"
 authors = ["Paul Makles <paulmakles@gmail.com>"]
 edition = "2018"
 
@@ -14,10 +15,8 @@ log = "0.4.11"
 dotenv = "0.15.0"
 dashmap = "5.2.0"
 linkify = "0.6.0"
-once_cell = "1.4.1"
+once_cell = "1.17.1"
 env_logger = "0.7.1"
-lazy_static = "1.4.0"
-ctrlc = { version = "3.0", features = ["termination"] }
 
 # Lang. Utilities
 regex = "1"
@@ -43,7 +42,6 @@ async-std = { version = "1.8.0", features = ["tokio1", "tokio02", "attributes"]
 
 # internal util
 lettre = "0.10.0-alpha.4"
-rauth = { git = "https://github.com/insertish/rauth", rev = "001a9698c56cea79e69e4ae71d7bc2cb48aec1a6" }
 
 # redis
 redis = { version = "0.21.2", features = ["async-std-comp"] }
@@ -51,14 +49,16 @@ mobc = { version = "0.7.3" }
 mobc-redis = { version = "0.7.0", default-features = false, features = ["async-std-comp"] }
 
 # web
-rocket = { version = "0.5.0-rc.1", default-features = false, features = ["json"] }
-mongodb = { version = "1.2.2", features = ["async-std-runtime"], default-features = false }
-rocket_cors = { git = "https://github.com/lawliet89/rocket_cors", rev = "5843861a88958c16bfaa0b40f0d8910772bcd2f6" }
+rocket = { version = "0.5.0-rc.2", default-features = false, features = ["json"] }
+rocket_empty = { version = "0.1.1", features = ["schema"] }
+rocket_authifier = { version = "1.0.7" }
 
 # spec generation
 schemars = "0.8.8"
-# rocket_okapi = "0.8.0-rc.1"
-rocket_okapi = { git = "https://github.com/insertish/okapi", rev = "dcf0df115596ee07a587a7a543cddf3d7944645b", features = [ "swagger" ] }
+revolt_rocket_okapi = { version = "0.9.1", features = [ "swagger" ] }
 
 # quark
 revolt-quark = { path = "../quark" }
+
+[build-dependencies]
+vergen = "7.5.0"

crates/delta/Dockerfile

@@ -1,23 +1,13 @@
 # Build Stage
-FROM rustlang/rust:nightly-slim AS builder
-USER 0:0
-WORKDIR /home/rust/src
-
-RUN USER=root cargo new --bin revolt
-WORKDIR /home/rust/src/revolt
-RUN apt-get update && apt-get install -y libssl-dev pkg-config
-
-COPY Cargo.toml Cargo.lock ./
-COPY assets ./assets
-COPY src ./src
-RUN cargo install --locked --path .
+FROM ghcr.io/revoltchat/base:latest AS builder
+RUN cargo install --locked --path crates/delta
 
 # Bundle Stage
 FROM debian:buster-slim
 RUN apt-get update && apt-get install -y ca-certificates
-COPY --from=builder /usr/local/cargo/bin/revolt ./
+COPY --from=builder /usr/local/cargo/bin/revolt-delta ./
 
 EXPOSE 8000
 ENV ROCKET_ADDRESS 0.0.0.0
 ENV ROCKET_PORT 8000
-CMD ["./revolt"]
+CMD ["./revolt-delta"]

crates/delta/LICENSE

@@ -1,661 +0,0 @@
-                    GNU AFFERO GENERAL PUBLIC LICENSE
-                       Version 3, 19 November 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU Affero General Public License is a free, copyleft license for
-software and other kinds of works, specifically designed to ensure
-cooperation with the community in the case of network server software.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-our General Public Licenses are intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  Developers that use our General Public Licenses protect your rights
-with two steps: (1) assert copyright on the software, and (2) offer
-you this License which gives you legal permission to copy, distribute
-and/or modify the software.
-
-  A secondary benefit of defending all users' freedom is that
-improvements made in alternate versions of the program, if they
-receive widespread use, become available for other developers to
-incorporate.  Many developers of free software are heartened and
-encouraged by the resulting cooperation.  However, in the case of
-software used on network servers, this result may fail to come about.
-The GNU General Public License permits making a modified version and
-letting the public access it on a server without ever releasing its
-source code to the public.
-
-  The GNU Affero General Public License is designed specifically to
-ensure that, in such cases, the modified source code becomes available
-to the community.  It requires the operator of a network server to
-provide the source code of the modified version running there to the
-users of that server.  Therefore, public use of a modified version, on
-a publicly accessible server, gives the public access to the source
-code of the modified version.
-
-  An older license, called the Affero General Public License and
-published by Affero, was designed to accomplish similar goals.  This is
-a different license, not a version of the Affero GPL, but Affero has
-released a new version of the Affero GPL which permits relicensing under
-this license.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU Affero General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Remote Network Interaction; Use with the GNU General Public License.
-
-  Notwithstanding any other provision of this License, if you modify the
-Program, your modified version must prominently offer all users
-interacting with it remotely through a computer network (if your version
-supports such interaction) an opportunity to receive the Corresponding
-Source of your version by providing access to the Corresponding Source
-from a network server at no charge, through some standard or customary
-means of facilitating copying of software.  This Corresponding Source
-shall include the Corresponding Source for any work covered by version 3
-of the GNU General Public License that is incorporated pursuant to the
-following paragraph.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the work with which it is combined will remain governed by version
-3 of the GNU General Public License.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU Affero General Public License from time to time.  Such new versions
-will be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU Affero General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU Affero General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU Affero General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    Revolt Delta
-    Copyright (C) 2022 Pawel Makles
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published
-    by the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If your software can interact with users remotely through a computer
-network, you should also make sure that it provides a way for users to
-get its source.  For example, if your program is a web application, its
-interface could display a "Source" link that leads users to an archive
-of the code.  There are many ways you could offer source, and different
-solutions will be better for different programs; see section 13 for the
-specific requirements.
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU AGPL, see
-<https://www.gnu.org/licenses/>.

crates/delta/LICENSE

@@ -0,0 +1 @@
+../../LICENSE

crates/delta/assets/templates/reset.html

@@ -1,63 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" lang="en-GB">
-<head>
-	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-	<title>Reset your password.</title>
-	<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
-	
-	<style type="text/css">
-		a[x-apple-data-detectors] {color: inherit !important;}
-	</style>
-	
-</head>
-<body style="margin: 0; padding: 0;">
-	<table border="0" cellpadding="0" cellspacing="0" width="100%">
-		<tr>
-			<td style="padding: 20px 0 30px 0;">
-				
-				<table align="center" border="0" cellpadding="0" cellspacing="0" width="600" style="border-collapse: collapse; border: 1px solid #cccccc;">
-					<tr>
-						<td align="center" bgcolor="#ff4654">
-							<img src="https://revolt.chat/header.png" alt="Revolt logo" width="600" height="168" style="display: block;" />
-						</td>
-					</tr>
-					<tr>
-						<td bgcolor="#ffffff" style="padding: 40px 30px 40px 30px;">
-							<table border="0" cellpadding="0" cellspacing="0" width="100%" style="border-collapse: collapse;">
-								<tr>
-									<td style="color: #153643; font-family: Arial, sans-serif;">
-										<h1 style="font-size: 24px; margin: 0;">Reset your password!</h1>
-									</td>
-								</tr>
-								<tr>
-									<td style="color: #153643; font-family: Arial, sans-serif; font-size: 16px; line-height: 24px; padding: 20px 0 0 0;">
-										<p>
-											You requested a password reset, if you didn't perform this action you can safely ignore this email.
-										</p>
-										<p style="margin: 0;">
-											Reset your password by navigating to <a href="{{url}}">{{url}}</a>.
-										</p>
-									</td>
-								</tr>
-							</table>
-						</td>
-					</tr>
-					<tr>
-						<td bgcolor="#ff4654" style="padding: 30px 30px;">
-							<table border="0" cellpadding="0" cellspacing="0" width="100%" style="border-collapse: collapse;">
-								<tr>
-									<td style="color: #ffffff; font-family: Arial, sans-serif; font-size: 14px;">
-										<p style="margin: 0;">Sent by Revolt. &middot; Website: <a style="color: white;" href="https://revolt.chat">https://revolt.chat</a></p>
-										<p>Revolt is a user-first chat platform built with modern web technologies.</p>
-									</td>
-								</tr>
-							</table>
-						</td>
-					</tr>
-				</table>
-				
-			</td>
-		</tr>
-	</table>
-</body>
-</html>

crates/delta/assets/templates/reset_plain.html

@@ -1,14 +0,0 @@
-<h2>Reset your password.</h2>
-<p>
-    You requested a password reset, if you did not perform this action you can safely ignore this email.
-</p>
-<p>
-    Reset your password here: <a href="{{url}}">{{url}}</a>
-</p>
-<br/>
-<p>
-   Sent by Revolt. · Website: <a href="https://revolt.chat">https://revolt.chat</a>
-</p>
-<p>
-    Revolt is a user-first chat platform built with modern web technologies.
-</p>

crates/delta/assets/templates/verify.html

@@ -1,63 +0,0 @@
-<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
-<html xmlns="http://www.w3.org/1999/xhtml" lang="en-GB">
-<head>
-	<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
-	<title>Verify your account.</title>
-	<meta name="viewport" content="width=device-width, initial-scale=1.0"/>
-	
-	<style type="text/css">
-		a[x-apple-data-detectors] {color: inherit !important;}
-	</style>
-	
-</head>
-<body style="margin: 0; padding: 0;">
-	<table border="0" cellpadding="0" cellspacing="0" width="100%">
-		<tr>
-			<td style="padding: 20px 0 30px 0;">
-				
-				<table align="center" border="0" cellpadding="0" cellspacing="0" width="600" style="border-collapse: collapse; border: 1px solid #cccccc;">
-					<tr>
-						<td align="center" bgcolor="#ff4654">
-							<img src="https://revolt.chat/header.png" alt="Revolt logo" width="600" height="168" style="display: block;" />
-						</td>
-					</tr>
-					<tr>
-						<td bgcolor="#ffffff" style="padding: 40px 30px 40px 30px;">
-							<table border="0" cellpadding="0" cellspacing="0" width="100%" style="border-collapse: collapse;">
-								<tr>
-									<td style="color: #153643; font-family: Arial, sans-serif;">
-										<h1 style="font-size: 24px; margin: 0;">You're almost there!</h1>
-									</td>
-								</tr>
-								<tr>
-									<td style="color: #153643; font-family: Arial, sans-serif; font-size: 16px; line-height: 24px; padding: 20px 0 0 0;">
-										<p>
-											Verify your account to be able to log into the platform. If you didn't perform this action you can safely ignore this email.
-										</p>
-										<p style="margin: 0;">
-											Please verify your account by navigating to <a href="{{url}}">{{url}}</a>.
-										</p>
-									</td>
-								</tr>
-							</table>
-						</td>
-					</tr>
-					<tr>
-						<td bgcolor="#ff4654" style="padding: 30px 30px;">
-							<table border="0" cellpadding="0" cellspacing="0" width="100%" style="border-collapse: collapse;">
-								<tr>
-									<td style="color: #ffffff; font-family: Arial, sans-serif; font-size: 14px;">
-										<p style="margin: 0;">Sent by Revolt. &middot; Website: <a style="color: white;" href="https://revolt.chat">https://revolt.chat</a></p>
-										<p>Revolt is a user-first chat platform built with modern web technologies.</p>
-									</td>
-								</tr>
-							</table>
-						</td>
-					</tr>
-				</table>
-				
-			</td>
-		</tr>
-	</table>
-</body>
-</html>

crates/delta/assets/templates/verify.txt

@@ -1,6 +0,0 @@
-You're almost there!
-If you did not perform this action you can safely ignore this email.
-
-Please verify your account here: {{url}}
-
-Sent by Revolt.

crates/delta/assets/templates/verify_plain.html

@@ -1,15 +0,0 @@
-<h2>You're almost there!</h2>
-<p>
-    Verify your account to be able to log into the platform.<br/>
-    If you did not perform this action you can safely ignore this email.
-</p>
-<p>
-    Please verify your account here: <a href="{{url}}">{{url}}</a>
-</p>
-<br/>
-<p>
-   Sent by Revolt. · Website: <a href="https://revolt.chat">https://revolt.chat</a>
-</p>
-<p>
-    Revolt is a user-first chat platform built with modern web technologies.
-</p>

crates/delta/build.rs

@@ -0,0 +1,16 @@
+use vergen::{vergen, Config};
+
+use std::process::Command;
+
+fn main() {
+    if let Ok(output) = Command::new("git")
+        .args(["config", "--get", "remote.origin.url"])
+        .output()
+    {
+        if let Ok(git_origin) = String::from_utf8(output.stdout) {
+            println!("cargo:rustc-env=GIT_ORIGIN_URL={git_origin}");
+        }
+    }
+
+    vergen(Config::default()).ok();
+}

crates/delta/src/main.rs

@@ -1,149 +1,71 @@
 #[macro_use]
 extern crate rocket;
 #[macro_use]
-extern crate rocket_okapi;
+extern crate revolt_rocket_okapi;
 #[macro_use]
 extern crate serde_json;
-#[macro_use]
-extern crate lazy_static;
-extern crate ctrlc;
 
 pub mod routes;
 pub mod util;
-pub mod version;
 
-use log::info;
-use rauth::{
-    config::{Captcha, Config, EmailVerification, SMTPSettings, Template, Templates},
-    logic::Auth,
-};
-use revolt_quark::variables::delta::{
-    APP_URL, HCAPTCHA_KEY, INVITE_ONLY, SMTP_FROM, SMTP_HOST, SMTP_PASSWORD, SMTP_USERNAME,
-    USE_EMAIL, USE_HCAPTCHA,
-};
+use async_std::channel::unbounded;
+use revolt_quark::authifier::{Authifier, AuthifierEvent};
+use revolt_quark::events::client::EventV1;
 use revolt_quark::DatabaseInfo;
-use rocket_cors::AllowedOrigins;
-use std::str::FromStr;
 
-#[async_std::main]
-async fn main() {
-    let _guard = revolt_quark::setup_logging();
-
-    info!(
-        "Starting Revolt server [version {}].",
-        crate::version::VERSION
-    );
+#[launch]
+async fn rocket() -> _ {
+    // Configure logging and environment
+    revolt_quark::configure!();
 
+    // Ensure environment variables are present
     revolt_quark::variables::delta::preflight_checks();
 
-    #[cfg(debug_assertions)]
-    ctrlc::set_handler(move || {
-        // Force ungraceful exit to avoid hang.
-        std::process::exit(0);
-    })
-    .expect("Error setting Ctrl-C handler");
-
-    let cors = rocket_cors::CorsOptions {
-        allowed_origins: AllowedOrigins::All,
-        allowed_methods: [
-            "Get", "Put", "Post", "Delete", "Options", "Head", "Trace", "Connect", "Patch",
-        ]
-        .iter()
-        .map(|s| FromStr::from_str(s).unwrap())
-        .collect(),
-        ..Default::default()
-    }
-    .to_cors()
-    .expect("Failed to create CORS.");
-
-    let mut config = Config {
-        email_verification: if *USE_EMAIL {
-            EmailVerification::Enabled {
-                smtp: SMTPSettings {
-                    from: (*SMTP_FROM).to_string(),
-                    host: (*SMTP_HOST).to_string(),
-                    username: (*SMTP_USERNAME).to_string(),
-                    password: (*SMTP_PASSWORD).to_string(),
-                    reply_to: Some("support@revolt.chat".into()),
-                    port: None,
-                    use_tls: None,
-                },
-                expiry: Default::default(),
-                templates: Templates {
-                    verify: Template {
-                        title: "Verify your Revolt account.".into(),
-                        text: include_str!(crate::asset!("templates/verify.txt")).into(),
-                        url: format!("{}/login/verify/", *APP_URL),
-                        html: None,
-                    },
-                    reset: Template {
-                        title: "Reset your Revolt password.".into(),
-                        text: include_str!(crate::asset!("templates/reset.txt")).into(),
-                        url: format!("{}/login/reset/", *APP_URL),
-                        html: None,
-                    },
-                    welcome: None,
-                },
-            }
-        } else {
-            EmailVerification::Disabled
-        },
-        ..Default::default()
-    };
-
-    if *INVITE_ONLY {
-        config.invite_only = true;
-    }
-
-    if *USE_HCAPTCHA {
-        config.captcha = Captcha::HCaptcha {
-            secret: HCAPTCHA_KEY.clone(),
-        };
-    }
-
+    // Setup database
     let db = DatabaseInfo::Auto.connect().await.unwrap();
     db.migrate_database().await.unwrap();
 
-    // This is entirely temporary code until rauth is migrated to quark.
-    // (and / or otherwise gets updated to MongoDB v2 driver)
-    let mongo_db = mongodb::Client::with_uri_str(
-        &std::env::var("MONGODB").unwrap_or_else(|_| "mongodb://localhost".to_string()),
-    )
-    .await
-    .expect("Failed to init db connection.");
+    // Setup Authifier event channel
+    let (sender, receiver) = unbounded();
 
-    rauth::entities::sync_models(&mongo_db.database("revolt")).await;
+    // Setup Authifier
+    let authifier = Authifier {
+        database: db.clone().into(),
+        config: revolt_quark::util::authifier::config(),
+        event_channel: Some(sender),
+    };
 
-    // Launch background task workers.
+    // Launch a listener for Authifier events
+    async_std::task::spawn(async move {
+        while let Ok(event) = receiver.recv().await {
+            match &event {
+                AuthifierEvent::CreateSession { .. } | AuthifierEvent::CreateAccount { .. } => {
+                    EventV1::Auth(event).global().await
+                }
+                AuthifierEvent::DeleteSession { user_id, .. }
+                | AuthifierEvent::DeleteAllSessions { user_id, .. } => {
+                    let id = user_id.to_string();
+                    EventV1::Auth(event).private(id).await
+                }
+            }
+        }
+    });
+
+    // Launch background task workers
     async_std::task::spawn(revolt_quark::tasks::start_workers(db.clone()));
 
-    let auth = Auth::new(mongo_db.database("revolt"), config);
+    // Configure CORS
+    let cors = revolt_quark::web::cors::new();
+
+    // Configure Rocket
     let rocket = rocket::build();
     routes::mount(rocket)
-        .mount("/", rocket_cors::catch_all_options_routes())
-        .mount("/", util::ratelimiter::routes())
-        .mount(
-            "/swagger/",
-            rocket_okapi::swagger_ui::make_swagger_ui(&rocket_okapi::swagger_ui::SwaggerUIConfig {
-                url: "../openapi.json".to_owned(),
-                ..Default::default()
-            }),
-        )
-        .manage(auth)
+        .mount("/", revolt_quark::web::cors::catch_all_options_routes())
+        .mount("/", revolt_quark::web::ratelimiter::routes())
+        .mount("/swagger/", revolt_quark::web::swagger::routes())
+        .manage(authifier)
         .manage(db)
         .manage(cors.clone())
-        .attach(util::ratelimiter::RatelimitFairing)
+        .attach(revolt_quark::web::ratelimiter::RatelimitFairing)
         .attach(cors)
-        .launch()
-        .await
-        .unwrap();
 }
-
-/// Resolve asset
-macro_rules! asset {
-    ($path:literal) => {
-        concat!(env!("CARGO_MANIFEST_DIR"), "/assets/", $path)
-    };
-}
-
-pub(crate) use asset;

crates/delta/src/routes/admin/message_query.rs

@@ -0,0 +1,31 @@
+use revolt_quark::{
+    models::{
+        message::{BulkMessageResponse, MessageQuery},
+        User,
+    },
+    Db, Error, Result,
+};
+use rocket::serde::json::Json;
+
+/// # Globally Fetch Messages
+///
+/// This is a privileged route to globally fetch messages.
+#[openapi(tag = "Admin")]
+#[post("/messages", data = "<data>")]
+pub async fn message_query(
+    db: &Db,
+    user: User,
+    data: Json<MessageQuery>,
+) -> Result<Json<BulkMessageResponse>> {
+    // Must be privileged for this route
+    if !user.privileged {
+        return Err(Error::NotPrivileged);
+    }
+
+    // Fetch data using query
+    let data = data.into_inner();
+    let messages = db.fetch_messages(data).await?;
+    BulkMessageResponse::transform(db, None, messages, Some(true))
+        .await
+        .map(Json)
+}

crates/delta/src/routes/admin/mod.rs

@@ -0,0 +1,9 @@
+use revolt_rocket_okapi::revolt_okapi::openapi3::OpenApi;
+use rocket::Route;
+
+mod message_query;
+mod stats;
+
+pub fn routes() -> (Vec<Route>, OpenApi) {
+    openapi_get_routes_spec![stats::stats, message_query::message_query]
+}

crates/delta/src/routes/admin/stats.rs

@@ -0,0 +1,13 @@
+use revolt_quark::models::stats::Stats;
+use revolt_quark::{Db, Result};
+
+use rocket::serde::json::Json;
+
+/// # Query Stats
+///
+/// Fetch various technical statistics.
+#[openapi(tag = "Admin")]
+#[get("/stats")]
+pub async fn stats(db: &Db) -> Result<Json<Stats>> {
+    Ok(Json(db.generate_stats().await?))
+}

crates/delta/src/routes/bots/mod.rs

@@ -1,5 +1,5 @@
+use revolt_rocket_okapi::revolt_okapi::openapi3::OpenApi;
 use rocket::Route;
-use rocket_okapi::okapi::openapi3::OpenApi;
 
 mod create;
 mod delete;

crates/delta/src/routes/channels/channel_delete.rs

@@ -2,13 +2,27 @@ use revolt_quark::{
     models::{channel::PartialChannel, Channel, User},
     perms, Db, EmptyResponse, Error, Permission, Ref, Result,
 };
+use serde::{Deserialize, Serialize};
+use validator::Validate;
+
+/// # Query Parameters
+#[derive(Validate, Serialize, Deserialize, JsonSchema, FromForm)]
+pub struct OptionsChannelDelete {
+    /// Whether to not send a leave message
+    leave_silently: Option<bool>,
+}
 
 /// # Close Channel
 ///
 /// Deletes a server channel, leaves a group or closes a group.
 #[openapi(tag = "Channel Information")]
-#[delete("/<target>")]
-pub async fn req(db: &Db, user: User, target: Ref) -> Result<EmptyResponse> {
+#[delete("/<target>?<options..>")]
+pub async fn req(
+    db: &Db,
+    user: User,
+    target: Ref,
+    options: OptionsChannelDelete,
+) -> Result<EmptyResponse> {
     let mut channel = target.as_channel(db).await?;
     let mut perms = perms(&user).channel(&channel);
     perms.throw_permission(db, Permission::ViewChannel).await?;
@@ -27,7 +41,12 @@ pub async fn req(db: &Db, user: User, target: Ref) -> Result<EmptyResponse> {
             .await
             .map(|_| EmptyResponse),
         Channel::Group { .. } => channel
-            .remove_user_from_group(db, &user.id, None)
+            .remove_user_from_group(
+                db,
+                &user.id,
+                None,
+                options.leave_silently.unwrap_or_default(),
+            )
             .await
             .map(|_| EmptyResponse),
         Channel::TextChannel { .. } | Channel::VoiceChannel { .. } => {

crates/delta/src/routes/channels/channel_edit.rs

@@ -16,20 +16,21 @@ use validator::Validate;
 pub struct DataEditChannel {
     /// Channel name
     #[validate(length(min = 1, max = 32))]
-    #[serde(skip_serializing_if = "Option::is_none")]
     name: Option<String>,
     /// Channel description
     #[validate(length(min = 0, max = 1024))]
-    #[serde(skip_serializing_if = "Option::is_none")]
     description: Option<String>,
+    /// Group owner
+    owner: Option<String>,
     /// Icon
     ///
     /// Provide an Autumn attachment Id.
     #[validate(length(min = 1, max = 128))]
     icon: Option<String>,
     /// Whether this channel is age-restricted
-    #[serde(skip_serializing_if = "Option::is_none")]
     nsfw: Option<bool>,
+    /// Whether this channel is archived
+    archived: Option<bool>,
     #[validate(length(min = 1))]
     remove: Option<Vec<FieldsChannel>>,
 }
@@ -59,12 +60,48 @@ pub async fn req(
         && data.description.is_none()
         && data.icon.is_none()
         && data.nsfw.is_none()
+        && data.owner.is_none()
         && data.remove.is_none()
     {
         return Ok(Json(channel));
     }
 
     let mut partial: PartialChannel = Default::default();
+
+    // Transfer group ownership
+    if let Some(new_owner) = data.owner {
+        if let Channel::Group {
+            owner, recipients, ..
+        } = &mut channel
+        {
+            // Make sure we are the owner of this group
+            if owner != &user.id {
+                return Err(Error::NotOwner);
+            }
+
+            // Ensure user is part of group
+            if !recipients.contains(&new_owner) {
+                return Err(Error::NotInGroup);
+            }
+
+            // Transfer ownership
+            partial.owner = Some(new_owner.to_string());
+            let old_owner = std::mem::replace(owner, new_owner.to_string());
+
+            // Notify clients
+            SystemMessage::ChannelOwnershipChanged {
+                from: old_owner,
+                to: new_owner,
+            }
+        } else {
+            return Err(Error::InvalidOperation);
+        }
+        .into_message(channel.id().to_string())
+        .create(db, &channel, None)
+        .await
+        .ok();
+    }
+
     match &mut channel {
         Channel::Group {
             id,

crates/delta/src/routes/channels/group_add_member.rs

@@ -1,5 +1,6 @@
 use revolt_quark::{
-    models::{Channel, User},
+    get_relationship,
+    models::{user::RelationshipStatus, Channel, User},
     perms, Db, EmptyResponse, Error, Permission, Ref, Result,
 };
 
@@ -22,6 +23,13 @@ pub async fn req(db: &Db, user: User, target: Ref, member: Ref) -> Result<EmptyR
     match &channel {
         Channel::Group { .. } => {
             let member = member.as_user(db).await?;
+            if !matches!(
+                get_relationship(&user, &member.id),
+                RelationshipStatus::Friend
+            ) {
+                return Err(Error::NotFriends);
+            }
+
             channel
                 .add_user_to_group(db, &member.id, &user.id)
                 .await

crates/delta/src/routes/channels/group_remove_member.rs

@@ -33,7 +33,7 @@ pub async fn req(db: &Db, user: User, target: Ref, member: Ref) -> Result<EmptyR
             }
 
             channel
-                .remove_user_from_group(db, &member.id, Some(&user.id))
+                .remove_user_from_group(db, &member.id, Some(&user.id), false)
                 .await
                 .map(|_| EmptyResponse)
         }

crates/delta/src/routes/channels/message_clear_reactions.rs

@@ -0,0 +1,34 @@
+use revolt_quark::{
+    models::{message::PartialMessage, User},
+    perms, Db, EmptyResponse, Permission, Ref, Result,
+};
+
+/// # Remove All Reactions from Message
+///
+/// Remove your own, someone else's or all of a given reaction.
+///
+/// Requires `ManageMessages` permission.
+#[openapi(tag = "Interactions")]
+#[delete("/<target>/messages/<msg>/reactions")]
+pub async fn clear_reactions(db: &Db, user: User, target: Ref, msg: Ref) -> Result<EmptyResponse> {
+    let channel = target.as_channel(db).await?;
+    perms(&user)
+        .channel(&channel)
+        .throw_permission_and_view_channel(db, Permission::ManageMessages)
+        .await?;
+
+    // Fetch relevant message
+    let mut message = msg.as_message_in(db, channel.id()).await?;
+
+    // Clear reactions
+    message
+        .update(
+            db,
+            PartialMessage {
+                reactions: Some(Default::default()),
+                ..Default::default()
+            },
+        )
+        .await
+        .map(|_| EmptyResponse)
+}

crates/delta/src/routes/channels/message_edit.rs

@@ -1,8 +1,9 @@
 use revolt_quark::{
     models::message::{PartialMessage, SendableEmbed},
     models::{Message, User},
+    perms,
     types::january::Embed,
-    Db, Error, Ref, Result, Timestamp,
+    Db, Error, Permission, Ref, Result, Timestamp,
 };
 
 use rocket::serde::json::Json;
@@ -28,7 +29,7 @@ pub struct DataEditMessage {
 pub async fn req(
     db: &Db,
     user: User,
-    target: String,
+    target: Ref,
     msg: Ref,
     edit: Json<DataEditMessage>,
 ) -> Result<Json<Message>> {
@@ -36,8 +37,17 @@ pub async fn req(
     edit.validate()
         .map_err(|error| Error::FailedValidation { error })?;
 
+    // Ensure we have permissions to send a message
+    let channel = target.as_channel(db).await?;
+    let mut permissions = perms(&user).channel(&channel);
+    permissions
+        .throw_permission_and_view_channel(db, Permission::SendMessage)
+        .await?;
+
+    Message::validate_sum(&edit.content, &edit.embeds)?;
+
     let mut message = msg.as_message(db).await?;
-    if message.channel != target {
+    if message.channel != channel.id() {
         return Err(Error::NotFound);
     }
 

crates/delta/src/routes/channels/message_query.rs

@@ -1,6 +1,8 @@
 use revolt_quark::{
     models::{
-        message::{BulkMessageResponse, MessageSort},
+        message::{
+            BulkMessageResponse, MessageFilter, MessageQuery, MessageSort, MessageTimePeriod,
+        },
         User,
     },
     perms, Db, Error, Permission, Ref, Result,
@@ -68,14 +70,28 @@ pub async fn req(
         sort,
         nearby,
         include_users,
-        ..
     } = options;
 
     let messages = db
-        .fetch_messages(channel.id(), limit, before, after, sort, nearby)
+        .fetch_messages(MessageQuery {
+            filter: MessageFilter {
+                channel: Some(channel.id().to_string()),
+                ..Default::default()
+            },
+            time_period: if let Some(nearby) = nearby {
+                MessageTimePeriod::Relative { nearby }
+            } else {
+                MessageTimePeriod::Absolute {
+                    before,
+                    after,
+                    sort,
+                }
+            },
+            limit,
+        })
         .await?;
 
-    BulkMessageResponse::transform(db, &channel, messages, include_users)
+    BulkMessageResponse::transform(db, Some(&channel), messages, include_users)
         .await
         .map(Json)
 }

crates/delta/src/routes/channels/message_react.rs

@@ -0,0 +1,29 @@
+use revolt_quark::{models::User, perms, Db, EmptyResponse, Permission, Ref, Result};
+
+/// # Add Reaction to Message
+///
+/// React to a given message.
+#[openapi(tag = "Interactions")]
+#[put("/<target>/messages/<msg>/reactions/<emoji>")]
+pub async fn react_message(
+    db: &Db,
+    user: User,
+    target: Ref,
+    msg: Ref,
+    emoji: Ref,
+) -> Result<EmptyResponse> {
+    let channel = target.as_channel(db).await?;
+    perms(&user)
+        .channel(&channel)
+        .throw_permission_and_view_channel(db, Permission::React)
+        .await?;
+
+    // Fetch relevant message
+    let message = msg.as_message_in(db, channel.id()).await?;
+
+    // Add the reaction
+    message
+        .add_reaction(db, &user, &emoji.id)
+        .await
+        .map(|_| EmptyResponse)
+}

crates/delta/src/routes/channels/message_search.rs

@@ -1,6 +1,8 @@
 use revolt_quark::{
     models::{
-        message::{BulkMessageResponse, MessageSort},
+        message::{
+            BulkMessageResponse, MessageFilter, MessageQuery, MessageSort, MessageTimePeriod,
+        },
         User,
     },
     perms, Db, Error, Permission, Ref, Result,
@@ -30,7 +32,7 @@ pub struct OptionsMessageSearch {
     after: Option<String>,
     /// Message sort direction
     ///
-    /// By default, it will be sorted by relevance.
+    /// By default, it will be sorted by latest.
     #[serde(default = "MessageSort::default")]
     sort: MessageSort,
     /// Whether to include user (and member, if server channel) objects
@@ -73,10 +75,22 @@ pub async fn req(
     } = options;
 
     let messages = db
-        .search_messages(channel.id(), &query, limit, before, after, sort)
+        .fetch_messages(MessageQuery {
+            filter: MessageFilter {
+                channel: Some(channel.id().to_string()),
+                query: Some(query),
+                ..Default::default()
+            },
+            time_period: MessageTimePeriod::Absolute {
+                before,
+                after,
+                sort: Some(sort),
+            },
+            limit,
+        })
         .await?;
 
-    BulkMessageResponse::transform(db, &channel, messages, include_users)
+    BulkMessageResponse::transform(db, Some(&channel), messages, include_users)
         .await
         .map(Json)
 }

crates/delta/src/routes/channels/message_send.rs

@@ -2,10 +2,12 @@ use std::collections::HashSet;
 
 use revolt_quark::{
     models::{
-        message::{Masquerade, Reply, SendableEmbed},
+        message::{Interactions, Masquerade, Reply, SendableEmbed},
         Message, User,
     },
-    perms, Db, Error, Permission, Ref, Result,
+    perms,
+    web::idempotency::IdempotencyKey,
+    Db, Error, Permission, Ref, Result,
 };
 
 use regex::Regex;
@@ -13,14 +15,14 @@ use rocket::serde::json::Json;
 use serde::{Deserialize, Serialize};
 use ulid::Ulid;
 use validator::Validate;
-
-use crate::util::idempotency::IdempotencyKey;
+use once_cell::sync::Lazy;
 
 #[derive(Validate, Serialize, Deserialize, JsonSchema)]
 pub struct DataMessageSend {
     /// Unique token to prevent duplicate message sending
     ///
     /// **This is deprecated and replaced by `Idempotency-Key`!**
+    #[validate(length(min = 1, max = 64))]
     nonce: Option<String>,
 
     /// Message content to send
@@ -32,17 +34,18 @@ pub struct DataMessageSend {
     /// Messages to reply to
     replies: Option<Vec<Reply>>,
     /// Embeds to include in message
+    ///
+    /// Text embed content contributes to the content length cap
     #[validate(length(min = 1, max = 10))]
     embeds: Option<Vec<SendableEmbed>>,
     /// Masquerade to apply to this message
     #[validate]
     masquerade: Option<Masquerade>,
+    /// Information about how this message should be interacted with
+    interactions: Option<Interactions>,
 }
 
-lazy_static! {
-    // ignoring I L O and U is intentional
-    static ref RE_MENTION: Regex = Regex::new(r"<@([0-9A-HJKMNP-TV-Z]{26})>").unwrap();
-}
+static RE_MENTION: Lazy<Regex> = Lazy::new(|| Regex::new(r"<@([0-9A-HJKMNP-TV-Z]{26})>").unwrap());
 
 /// # Send Message
 ///
@@ -60,14 +63,20 @@ pub async fn message_send(
     data.validate()
         .map_err(|error| Error::FailedValidation { error })?;
 
+    // Validate Message is within reasonable length limits
+    Message::validate_sum(&data.content, &data.embeds)?;
+
+    // Ensure the request is unique
     idempotency.consume_nonce(data.nonce).await?;
 
+    // Ensure we have permissions to send a message
     let channel = target.as_channel(db).await?;
     let mut permissions = perms(&user).channel(&channel);
     permissions
         .throw_permission_and_view_channel(db, Permission::SendMessage)
         .await?;
 
+    // Check the message is not empty
     if (data.content.as_ref().map_or(true, |v| v.is_empty()))
         && (data.attachments.as_ref().map_or(true, |v| v.is_empty()))
         && (data.embeds.as_ref().map_or(true, |v| v.is_empty()))
@@ -75,12 +84,29 @@ pub async fn message_send(
         return Err(Error::EmptyMessage);
     }
 
+    // Ensure restrict_reactions is not specified without reactions list
+    if let Some(interactions) = &data.interactions {
+        if interactions.restrict_reactions {
+            let disallowed = if let Some(list) = &interactions.reactions {
+                list.is_empty()
+            } else {
+                true
+            };
+
+            if disallowed {
+                return Err(Error::InvalidProperty);
+            }
+        }
+    }
+
+    // Start constructing the message
     let message_id = Ulid::new().to_string();
     let mut message = Message {
         id: message_id.clone(),
         channel: channel.id().to_string(),
         author: user.id.clone(),
         masquerade: data.masquerade,
+        interactions: data.interactions.unwrap_or_default(),
         ..Default::default()
     };
 
@@ -95,13 +121,22 @@ pub async fn message_send(
     }
 
     // 2. Verify permissions for masquerade.
-    if message.masquerade.is_some() {
+    if let Some(masq) = &message.masquerade {
         permissions
             .throw_permission(db, Permission::Masquerade)
             .await?;
+
+        if masq.colour.is_some() {
+            permissions
+                .throw_permission(db, Permission::ManageRole)
+                .await?;
+        }
     }
 
-    // 3. Verify replies are valid.
+    // 3. Ensure interactions information is correct
+    message.interactions.validate(db, &mut permissions).await?;
+
+    // 4. Verify replies are valid.
     let mut replies = HashSet::new();
     if let Some(entries) = data.replies {
         if entries.len() > 5 {
@@ -134,7 +169,19 @@ pub async fn message_send(
             .replace(replies.into_iter().collect::<Vec<String>>());
     }
 
-    // 4. Add attachments to message.
+    // 5. Process included embeds.
+    let mut embeds = vec![];
+    if let Some(sendable_embeds) = data.embeds {
+        for sendable_embed in sendable_embeds {
+            embeds.push(sendable_embed.into_embed(db, message_id.clone()).await?)
+        }
+    }
+
+    if !embeds.is_empty() {
+        message.embeds.replace(embeds);
+    }
+
+    // 6. Add attachments to message.
     let mut attachments = vec![];
     if let Some(ids) = &data.attachments {
         if !ids.is_empty() {
@@ -160,22 +207,10 @@ pub async fn message_send(
         message.attachments.replace(attachments);
     }
 
-    // 5. Process included embeds.
-    let mut embeds = vec![];
-    if let Some(sendable_embeds) = data.embeds {
-        for sendable_embed in sendable_embeds {
-            embeds.push(sendable_embed.into_embed(db, message_id.clone()).await?)
-        }
-    }
-
-    if !embeds.is_empty() {
-        message.embeds.replace(embeds);
-    }
-
-    // 6. Set content
+    // 7. Set content
     message.content = data.content;
 
-    // 7. Pass-through nonce value for clients
+    // 8. Pass-through nonce value for clients
     message.nonce = Some(idempotency.into_key());
 
     message.create(db, &channel, Some(&user)).await?;

crates/delta/src/routes/channels/message_unreact.rs

@@ -0,0 +1,58 @@
+use revolt_quark::{models::User, perms, Db, EmptyResponse, Permission, Ref, Result};
+use serde::{Deserialize, Serialize};
+
+/// # Query Parameters
+#[derive(Serialize, Deserialize, JsonSchema, FromForm)]
+pub struct OptionsUnreact {
+    /// Remove a specific user's reaction
+    user_id: Option<String>,
+    /// Remove all reactions
+    remove_all: Option<bool>,
+}
+
+/// # Remove Reaction(s) to Message
+///
+/// Remove your own, someone else's or all of a given reaction.
+///
+/// Requires `ManageMessages` if changing others' reactions.
+#[openapi(tag = "Interactions")]
+#[delete("/<target>/messages/<msg>/reactions/<emoji>?<options..>")]
+pub async fn unreact_message(
+    db: &Db,
+    user: User,
+    target: Ref,
+    msg: Ref,
+    emoji: Ref,
+    options: OptionsUnreact,
+) -> Result<EmptyResponse> {
+    let channel = target.as_channel(db).await?;
+    let mut permissions = perms(&user).channel(&channel);
+    permissions
+        .throw_permission_and_view_channel(db, Permission::React)
+        .await?;
+
+    // Check if we need to escalate permissions
+    let remove_all = options.remove_all.unwrap_or_default();
+    if options.user_id.is_some() || remove_all {
+        permissions
+            .throw_permission(db, Permission::ManageMessages)
+            .await?;
+    }
+
+    // Fetch relevant message
+    let message = msg.as_message_in(db, channel.id()).await?;
+
+    // Check if we should wipe all of this reaction
+    if remove_all {
+        return message
+            .clear_reaction(db, &emoji.id)
+            .await
+            .map(|_| EmptyResponse);
+    }
+
+    // Remove the reaction
+    message
+        .remove_reaction(db, options.user_id.as_ref().unwrap_or(&user.id), &emoji.id)
+        .await
+        .map(|_| EmptyResponse)
+}

crates/delta/src/routes/channels/mod.rs

@@ -1,5 +1,5 @@
+use revolt_rocket_okapi::revolt_okapi::openapi3::OpenApi;
 use rocket::Route;
-use rocket_okapi::okapi::openapi3::OpenApi;
 
 mod channel_ack;
 mod channel_delete;
@@ -11,13 +11,16 @@ mod group_remove_member;
 mod invite_create;
 mod members_fetch;
 mod message_bulk_delete;
+mod message_clear_reactions;
 mod message_delete;
 mod message_edit;
 mod message_fetch;
 mod message_query;
 mod message_query_stale;
+mod message_react;
 mod message_search;
 mod message_send;
+mod message_unreact;
 mod permissions_set;
 mod permissions_set_default;
 mod voice_join;
@@ -44,5 +47,8 @@ pub fn routes() -> (Vec<Route>, OpenApi) {
         voice_join::req,
         permissions_set::req,
         permissions_set_default::req,
+        message_react::react_message,
+        message_unreact::unreact_message,
+        message_clear_reactions::clear_reactions
     ]
 }

crates/delta/src/routes/customisation/emoji_create.rs

@@ -0,0 +1,81 @@
+use revolt_quark::models::emoji::EmojiParent;
+use revolt_quark::models::{Emoji, File, User};
+use revolt_quark::{perms, Db, Error, Permission, Result};
+use serde::Deserialize;
+use validator::Validate;
+
+use crate::util::regex::RE_EMOJI;
+
+use rocket::serde::json::Json;
+
+/// # Emoji Data
+#[derive(Validate, Deserialize, JsonSchema)]
+pub struct DataCreateEmoji {
+    /// Server name
+    #[validate(length(min = 1, max = 32), regex = "RE_EMOJI")]
+    name: String,
+    /// Parent information
+    parent: EmojiParent,
+    /// Whether the emoji is mature
+    #[serde(default)]
+    nsfw: bool,
+}
+
+/// # Create New Emoji
+///
+/// Create an emoji by its Autumn upload id.
+#[openapi(tag = "Emojis")]
+#[put("/emoji/<id>", data = "<data>")]
+pub async fn create_emoji(
+    db: &Db,
+    user: User,
+    id: String,
+    data: Json<DataCreateEmoji>,
+) -> Result<Json<Emoji>> {
+    let data = data.into_inner();
+    data.validate()
+        .map_err(|error| Error::FailedValidation { error })?;
+
+    // Bots cannot manage emojis
+    if user.bot.is_some() {
+        return Err(Error::IsBot);
+    }
+
+    // Validate we have permission to write into parent
+    match &data.parent {
+        EmojiParent::Server { id } => {
+            let server = db.fetch_server(id).await?;
+
+            // Check for permission
+            perms(&user)
+                .server(&server)
+                .throw_permission(db, Permission::ManageCustomisation)
+                .await?;
+
+            // Check that there are no more than 100 emoji
+            // ! FIXME: hardcoded upper limit
+            let emojis = db.fetch_emoji_by_parent_id(&server.id).await?;
+            if emojis.len() > 99 {
+                return Err(Error::TooManyEmoji);
+            }
+        }
+        EmojiParent::Detached => return Err(Error::InvalidOperation),
+    };
+
+    // Find the relevant attachment
+    let attachment = File::use_emoji(db, &id, &id).await?;
+
+    // Create the emoji object
+    let emoji = Emoji {
+        id,
+        parent: data.parent,
+        creator_id: user.id,
+        name: data.name,
+        animated: "image/gif" == &attachment.content_type,
+        nsfw: data.nsfw,
+    };
+
+    // Save emoji
+    emoji.create(db).await?;
+    Ok(Json(emoji))
+}

crates/delta/src/routes/customisation/emoji_delete.rs

@@ -0,0 +1,37 @@
+use revolt_quark::models::{emoji::EmojiParent, User};
+use revolt_quark::{perms, Db, EmptyResponse, Error, Permission, Ref, Result};
+
+/// # Delete Emoji
+///
+/// Delete an emoji by its id.
+#[openapi(tag = "Emojis")]
+#[delete("/emoji/<id>")]
+pub async fn delete_emoji(db: &Db, user: User, id: Ref) -> Result<EmptyResponse> {
+    // Bots cannot manage emoji
+    if user.bot.is_some() {
+        return Err(Error::IsBot);
+    }
+
+    // Fetch the emoji
+    let emoji = id.as_emoji(db).await?;
+
+    // If we uploaded the emoji, then we have permission to delete it
+    if emoji.creator_id != user.id {
+        // Otherwise, validate we have permission to delete from parent
+        match &emoji.parent {
+            EmojiParent::Server { id } => {
+                let server = db.fetch_server(id).await?;
+
+                // Check for permission
+                perms(&user)
+                    .server(&server)
+                    .throw_permission(db, Permission::ManageCustomisation)
+                    .await?;
+            }
+            EmojiParent::Detached => return Ok(EmptyResponse),
+        };
+    }
+
+    // Delete the emoji
+    emoji.delete(db).await.map(|_| EmptyResponse)
+}

crates/delta/src/routes/customisation/emoji_fetch.rs

@@ -0,0 +1,13 @@
+use revolt_quark::models::{Emoji, User};
+use revolt_quark::{Db, Ref, Result};
+
+use rocket::serde::json::Json;
+
+/// # Fetch Emoji
+///
+/// Fetch an emoji by its id.
+#[openapi(tag = "Emojis")]
+#[get("/emoji/<id>")]
+pub async fn fetch_emoji(db: &Db, _user: User, id: Ref) -> Result<Json<Emoji>> {
+    id.as_emoji(db).await.map(Json)
+}

crates/delta/src/routes/customisation/mod.rs

@@ -0,0 +1,14 @@
+use revolt_rocket_okapi::revolt_okapi::openapi3::OpenApi;
+use rocket::Route;
+
+mod emoji_create;
+mod emoji_delete;
+mod emoji_fetch;
+
+pub fn routes() -> (Vec<Route>, OpenApi) {
+    openapi_get_routes_spec![
+        emoji_create::create_emoji,
+        emoji_delete::delete_emoji,
+        emoji_fetch::fetch_emoji
+    ]
+}

crates/delta/src/routes/invites/invite_fetch.rs

@@ -23,6 +23,9 @@ pub enum InviteResponse {
         /// Attachment for server banner
         #[serde(skip_serializing_if = "Option::is_none")]
         server_banner: Option<File>,
+        /// Enum of server flags
+        #[serde(skip_serializing_if = "Option::is_none")]
+        server_flags: Option<i32>,
         /// Id of server channel
         channel_id: String,
         /// Name of server channel
@@ -94,6 +97,7 @@ pub async fn req(db: &Db, target: Ref) -> Result<Json<InviteResponse>> {
                         server_name: server.name,
                         server_icon: server.icon,
                         server_banner: server.banner,
+                        server_flags: server.flags,
                         channel_id: id,
                         channel_name: name,
                         channel_description: description,

crates/delta/src/routes/invites/mod.rs

@@ -1,5 +1,5 @@
+use revolt_rocket_okapi::revolt_okapi::openapi3::OpenApi;
 use rocket::Route;
-use rocket_okapi::okapi::openapi3::OpenApi;
 
 mod invite_delete;
 mod invite_fetch;

crates/delta/src/routes/mod.rs

@@ -1,14 +1,17 @@
+use revolt_rocket_okapi::{revolt_okapi::openapi3::OpenApi, settings::OpenApiSettings};
 pub use rocket::http::Status;
 pub use rocket::response::Redirect;
 use rocket::{Build, Rocket};
-use rocket_okapi::{okapi::openapi3::OpenApi, settings::OpenApiSettings};
 
+mod admin;
 mod bots;
 mod channels;
+mod customisation;
 mod invites;
 mod onboard;
 mod push;
 mod root;
+mod safety;
 mod servers;
 mod sync;
 mod users;
@@ -20,13 +23,17 @@ pub fn mount(mut rocket: Rocket<Build>) -> Rocket<Build> {
         rocket, "/".to_owned(), settings,
         "/" => (vec![], custom_openapi_spec()),
         "" => openapi_get_routes_spec![root::root, root::ping],
+        "/admin" => admin::routes(),
         "/users" => users::routes(),
         "/bots" => bots::routes(),
         "/channels" => channels::routes(),
         "/servers" => servers::routes(),
         "/invites" => invites::routes(),
-        "/auth/account" => rauth::web::account::routes(),
-        "/auth/session" => rauth::web::session::routes(),
+        "/custom" => customisation::routes(),
+        "/safety" => safety::routes(),
+        "/auth/account" => rocket_authifier::routes::account::routes(),
+        "/auth/session" => rocket_authifier::routes::session::routes(),
+        "/auth/mfa" => rocket_authifier::routes::mfa::routes(),
         "/onboard" => onboard::routes(),
         "/push" => push::routes(),
         "/sync" => sync::routes(),
@@ -36,7 +43,7 @@ pub fn mount(mut rocket: Rocket<Build>) -> Rocket<Build> {
 }
 
 fn custom_openapi_spec() -> OpenApi {
-    use rocket_okapi::okapi::openapi3::*;
+    use revolt_rocket_okapi::revolt_okapi::openapi3::*;
 
     let mut extensions = schemars::Map::new();
     extensions.insert(
@@ -77,6 +84,7 @@ fn custom_openapi_spec() -> OpenApi {
               "Channel Invites",
               "Channel Permissions",
               "Messaging",
+              "Interactions",
               "Groups",
               "Voice"
             ]
@@ -95,12 +103,26 @@ fn custom_openapi_spec() -> OpenApi {
               "Invites"
             ]
           },
+          {
+            "name": "Customisation",
+            "tags": [
+              "Emojis"
+            ]
+          },
+          {
+            "name": "Platform Administration",
+            "tags": [
+              "Admin",
+              "User Safety"
+            ]
+          },
           {
             "name": "Authentication",
             "tags": [
               "Account",
               "Session",
-              "Onboarding"
+              "Onboarding",
+              "MFA"
             ]
           },
           {
@@ -117,7 +139,7 @@ fn custom_openapi_spec() -> OpenApi {
         openapi: OpenApi::default_version(),
         info: Info {
             title: "Revolt API".to_owned(),
-            description: Some("User-first privacy focused chat platform.".to_owned()),
+            description: Some("Open source user-first chat platform.".to_owned()),
             terms_of_service: Some("https://revolt.chat/terms".to_owned()),
             contact: Some(Contact {
                 name: Some("Revolt Support".to_owned()),
@@ -130,7 +152,7 @@ fn custom_openapi_spec() -> OpenApi {
                 url: Some("https://github.com/revoltchat/delta/blob/master/LICENSE".to_owned()),
                 ..Default::default()
             }),
-            version: "0.5.3-rc.1".to_owned(),
+            version: env!("CARGO_PKG_VERSION").to_string(),
             ..Default::default()
         },
         servers: vec![
@@ -242,6 +264,11 @@ fn custom_openapi_spec() -> OpenApi {
                 description: Some("Create and manage sessions".to_owned()),
                 ..Default::default()
             },
+            Tag {
+                name: "MFA".to_owned(),
+                description: Some("Multi-factor Authentication".to_owned()),
+                ..Default::default()
+            },
             Tag {
                 name: "Onboarding".to_owned(),
                 description: Some(

crates/delta/src/routes/onboard/complete.rs

@@ -1,7 +1,8 @@
 use crate::util::regex::RE_USERNAME;
-use revolt_quark::{models::User, Database, EmptyResponse, Error, Result};
+use revolt_quark::{
+    authifier::models::Session, models::User, Database, EmptyResponse, Error, Result,
+};
 
-use rauth::entities::Session;
 use rocket::{serde::json::Json, State};
 use serde::{Deserialize, Serialize};
 use validator::Validate;
@@ -33,13 +34,10 @@ pub async fn req(
     data.validate()
         .map_err(|error| Error::FailedValidation { error })?;
 
-    if db.is_username_taken(&data.username).await? {
-        return Err(Error::UsernameTaken);
-    }
-
+    let username = User::validate_username(db, data.username).await?;
     let user = User {
         id: session.user_id,
-        username: data.username,
+        username,
         ..Default::default()
     };
 

crates/delta/src/routes/onboard/hello.rs

@@ -1,5 +1,4 @@
-use rauth::entities::Session;
-use revolt_quark::models::User;
+use revolt_quark::{authifier::models::Session, models::User};
 use rocket::serde::json::Json;
 use serde::Serialize;
 

crates/delta/src/routes/onboard/mod.rs

@@ -1,5 +1,5 @@
+use revolt_rocket_okapi::revolt_okapi::openapi3::OpenApi;
 use rocket::Route;
-use rocket_okapi::okapi::openapi3::OpenApi;
 
 mod complete;
 mod hello;

crates/delta/src/routes/push/mod.rs

@@ -1,5 +1,5 @@
+use revolt_rocket_okapi::revolt_okapi::openapi3::OpenApi;
 use rocket::Route;
-use rocket_okapi::okapi::openapi3::OpenApi;
 
 mod subscribe;
 mod unsubscribe;

crates/delta/src/routes/push/subscribe.rs

@@ -1,9 +1,11 @@
-use revolt_quark::{EmptyResponse, Error, Result};
-
-use rauth::{
-    entities::{Model, Session, WebPushSubscription},
-    logic::Auth,
+use revolt_quark::{
+    authifier::{
+        models::{Session, WebPushSubscription},
+        Authifier,
+    },
+    EmptyResponse, Error, Result,
 };
+
 use rocket::{serde::json::Json, State};
 
 /// # Push Subscribe
@@ -14,13 +16,13 @@ use rocket::{serde::json::Json, State};
 #[openapi(tag = "Web Push")]
 #[post("/subscribe", data = "<data>")]
 pub async fn req(
-    auth: &State<Auth>,
+    authifier: &State<Authifier>,
     mut session: Session,
     data: Json<WebPushSubscription>,
 ) -> Result<EmptyResponse> {
     session.subscription = Some(data.into_inner());
     session
-        .save(&auth.db, None)
+        .save(authifier)
         .await
         .map(|_| EmptyResponse)
         .map_err(|_| Error::DatabaseError {

crates/delta/src/routes/push/unsubscribe.rs

@@ -1,9 +1,8 @@
-use revolt_quark::{EmptyResponse, Error, Result};
-
-use rauth::{
-    entities::{Model, Session},
-    logic::Auth,
+use revolt_quark::{
+    authifier::{models::Session, Authifier},
+    EmptyResponse, Error, Result,
 };
+
 use rocket::State;
 
 /// # Unsubscribe
@@ -11,10 +10,10 @@ use rocket::State;
 /// Remove the Web Push subscription associated with the current session.
 #[openapi(tag = "Web Push")]
 #[post("/unsubscribe")]
-pub async fn req(auth: &State<Auth>, mut session: Session) -> Result<EmptyResponse> {
+pub async fn req(authifier: &State<Authifier>, mut session: Session) -> Result<EmptyResponse> {
     session.subscription = None;
     session
-        .save(&auth.db, None)
+        .save(authifier)
         .await
         .map(|_| EmptyResponse)
         .map_err(|_| Error::DatabaseError {

crates/delta/src/routes/root.rs

@@ -54,6 +54,21 @@ pub struct RevoltFeatures {
     pub voso: VoiceFeature,
 }
 
+/// # Build Information
+#[derive(Serialize, JsonSchema, Debug)]
+pub struct BuildInformation {
+    /// Commit Hash
+    pub commit_sha: String,
+    /// Commit Timestamp
+    pub commit_timestamp: String,
+    /// Git Semver
+    pub semver: String,
+    /// Git Origin URL
+    pub origin_url: String,
+    /// Build Timestamp
+    pub timestamp: String,
+}
+
 /// # Server Configuration
 #[derive(Serialize, JsonSchema, Debug)]
 pub struct RevoltConfig {
@@ -67,6 +82,8 @@ pub struct RevoltConfig {
     pub app: String,
     /// Web Push VAPID public key
     pub vapid: String,
+    /// Build information
+    pub build: BuildInformation,
 }
 
 /// # Query Node
@@ -76,7 +93,7 @@ pub struct RevoltConfig {
 #[get("/")]
 pub async fn root() -> Result<Json<RevoltConfig>> {
     Ok(Json(RevoltConfig {
-        revolt: crate::version::VERSION.to_string(),
+        revolt: env!("CARGO_PKG_VERSION").to_string(),
         features: RevoltFeatures {
             captcha: CaptchaFeature {
                 enabled: *USE_HCAPTCHA,
@@ -101,6 +118,23 @@ pub async fn root() -> Result<Json<RevoltConfig>> {
         ws: EXTERNAL_WS_URL.to_string(),
         app: APP_URL.to_string(),
         vapid: VAPID_PUBLIC_KEY.to_string(),
+        build: BuildInformation {
+            commit_sha: option_env!("VERGEN_GIT_SHA")
+                .unwrap_or_else(|| "<failed to generate>")
+                .to_string(),
+            commit_timestamp: option_env!("VERGEN_GIT_COMMIT_TIMESTAMP")
+                .unwrap_or_else(|| "<failed to generate>")
+                .to_string(),
+            semver: option_env!("VERGEN_GIT_SEMVER")
+                .unwrap_or_else(|| "<failed to generate>")
+                .to_string(),
+            origin_url: option_env!("GIT_ORIGIN_URL")
+                .unwrap_or_else(|| "<failed to generate>")
+                .to_string(),
+            timestamp: option_env!("VERGEN_BUILD_TIMESTAMP")
+                .unwrap_or_else(|| "<failed to generate>")
+                .to_string(),
+        },
     }))
 }
 

crates/delta/src/routes/safety/edit_report.rs

@@ -0,0 +1,56 @@
+use revolt_quark::{
+    models::{
+        report::{PartialReport, ReportStatus},
+        Report, User,
+    },
+    Db, Error, Ref, Result,
+};
+use rocket::serde::json::Json;
+use serde::Deserialize;
+use validator::Validate;
+
+/// # Report Data
+#[derive(Validate, Deserialize, JsonSchema)]
+pub struct DataEditReport {
+    /// New report status
+    status: Option<ReportStatus>,
+    /// Report notes
+    notes: Option<String>,
+}
+
+/// # Edit Report
+///
+/// Edit a report.
+#[openapi(tag = "User Safety")]
+#[patch("/reports/<report>", data = "<edit>")]
+pub async fn edit_report(
+    db: &Db,
+    user: User,
+    report: Ref,
+    edit: Json<DataEditReport>,
+) -> Result<Json<Report>> {
+    // Must be privileged for this route
+    if !user.privileged {
+        return Err(Error::NotPrivileged);
+    }
+
+    // Validate data
+    let edit = edit.into_inner();
+    edit.validate()
+        .map_err(|error| Error::FailedValidation { error })?;
+
+    // Create and apply update to report
+    let mut report = report.as_report(db).await?;
+    report
+        .update(
+            db,
+            PartialReport {
+                status: edit.status,
+                notes: edit.notes,
+                ..Default::default()
+            },
+        )
+        .await?;
+
+    Ok(Json(report))
+}

crates/delta/src/routes/safety/fetch_report.rs

@@ -0,0 +1,17 @@
+use revolt_quark::models::{Report, User};
+use revolt_quark::{Db, Error, Result};
+use rocket::serde::json::Json;
+
+/// # Fetch Report
+///
+/// Fetch a report by its ID
+#[openapi(tag = "User Safety")]
+#[get("/report/<id>")]
+pub async fn fetch_report(db: &Db, user: User, id: String) -> Result<Json<Report>> {
+    // Must be privileged for this route
+    if !user.privileged {
+        return Err(Error::NotPrivileged);
+    }
+
+    db.fetch_report(&id).await.map(Json)
+}

crates/delta/src/routes/safety/fetch_reports.rs

@@ -0,0 +1,17 @@
+use revolt_quark::models::{Report, User};
+use revolt_quark::{Db, Error, Result};
+use rocket::serde::json::Json;
+
+/// # Fetch Reports
+///
+/// Fetch all available reports
+#[openapi(tag = "User Safety")]
+#[get("/reports")]
+pub async fn fetch_reports(db: &Db, user: User) -> Result<Json<Vec<Report>>> {
+    // Must be privileged for this route
+    if !user.privileged {
+        return Err(Error::NotPrivileged);
+    }
+
+    db.fetch_reports().await.map(Json)
+}

crates/delta/src/routes/safety/fetch_snapshot.rs

@@ -0,0 +1,82 @@
+use std::collections::HashSet;
+
+use revolt_quark::models::snapshot::{SnapshotContent, SnapshotWithContext};
+use revolt_quark::models::{Channel, User};
+use revolt_quark::{Db, Error, Result};
+use rocket::serde::json::Json;
+
+/// # Fetch Snapshot
+///
+/// Fetch a snapshot for a given report
+#[openapi(tag = "User Safety")]
+#[get("/snapshot/<report_id>")]
+pub async fn fetch_snapshot(
+    db: &Db,
+    user: User,
+    report_id: String,
+) -> Result<Json<SnapshotWithContext>> {
+    // Must be privileged for this route
+    if !user.privileged {
+        return Err(Error::NotPrivileged);
+    }
+
+    // Fetch snapshot
+    let snapshot = db.fetch_snapshot(&report_id).await?;
+
+    // Resolve and fetch IDs of associated content
+    let mut user_ids: HashSet<&str> = HashSet::new();
+    let mut channel_ids: HashSet<&str> = HashSet::new();
+
+    match &snapshot.content {
+        SnapshotContent::Message {
+            prior_context,
+            leading_context,
+            message,
+        } => {
+            for msg in prior_context {
+                user_ids.insert(&msg.author);
+            }
+
+            for msg in leading_context {
+                user_ids.insert(&msg.author);
+            }
+
+            user_ids.insert(&message.author);
+            channel_ids.insert(&message.channel);
+        }
+        SnapshotContent::User(user) => {
+            user_ids.insert(&user.id);
+        }
+        SnapshotContent::Server(server) => {
+            for channel in &server.channels {
+                channel_ids.insert(channel);
+            }
+        }
+    }
+
+    // Collect user and channel IDs
+    let user_ids: Vec<String> = user_ids.into_iter().map(|s| s.to_owned()).collect();
+    let channel_ids: Vec<String> = channel_ids.into_iter().map(|s| s.to_owned()).collect();
+
+    // Fetch users and channels
+    let users = db.fetch_users(&user_ids).await?;
+    let channels = db.fetch_channels(&channel_ids).await?;
+
+    // Pull out first server from channels if possible
+    let server = if let Some(server_id) = channels.iter().find_map(|channel| match channel {
+        Channel::TextChannel { server, .. } => Some(server),
+        _ => None,
+    }) {
+        Some(db.fetch_server(server_id).await?)
+    } else {
+        None
+    };
+
+    // Return snapshot with context
+    Ok(Json(SnapshotWithContext {
+        snapshot,
+        users,
+        channels,
+        server,
+    }))
+}

crates/delta/src/routes/safety/mod.rs

@@ -0,0 +1,21 @@
+use revolt_rocket_okapi::revolt_okapi::openapi3::OpenApi;
+use rocket::Route;
+
+mod edit_report;
+mod fetch_report;
+mod fetch_reports;
+mod report_content;
+
+mod fetch_snapshot;
+
+pub fn routes() -> (Vec<Route>, OpenApi) {
+    openapi_get_routes_spec![
+        // Reports
+        edit_report::edit_report,
+        fetch_report::fetch_report,
+        fetch_reports::fetch_reports,
+        report_content::report_content,
+        // Snapshots
+        fetch_snapshot::fetch_snapshot
+    ]
+}

crates/delta/src/routes/safety/report_content.rs

@@ -0,0 +1,170 @@
+use revolt_quark::events::client::EventV1;
+use revolt_quark::models::message::{MessageFilter, MessageQuery, MessageSort, MessageTimePeriod};
+use revolt_quark::models::report::{ReportStatus, ReportedContent};
+use revolt_quark::models::snapshot::{Snapshot, SnapshotContent};
+use revolt_quark::models::{Report, User};
+use revolt_quark::{Db, Error, Result};
+use serde::Deserialize;
+use ulid::Ulid;
+use validator::Validate;
+
+use rocket::serde::json::Json;
+
+/// # Report Data
+#[derive(Validate, Deserialize, JsonSchema)]
+pub struct DataReportContent {
+    /// Content being reported
+    content: ReportedContent,
+    /// Additional report description
+    #[validate(length(min = 0, max = 1000))]
+    #[serde(default)]
+    additional_context: String,
+}
+
+/// # Report Content
+///
+/// Report a piece of content to the moderation team.
+#[openapi(tag = "User Safety")]
+#[post("/report", data = "<data>")]
+pub async fn report_content(db: &Db, user: User, data: Json<DataReportContent>) -> Result<()> {
+    let data = data.into_inner();
+    data.validate()
+        .map_err(|error| Error::FailedValidation { error })?;
+
+    // Bots cannot create reports
+    if user.bot.is_some() {
+        return Err(Error::IsBot);
+    }
+
+    // Find the content and create a snapshot of it
+    // Also retrieve any references to Files
+    let (content, files): (SnapshotContent, Vec<String>) = match &data.content {
+        ReportedContent::Message { id, .. } => {
+            let message = db.fetch_message(id).await?;
+
+            // Users cannot report themselves
+            if message.author == user.id {
+                return Err(Error::CannotReportYourself);
+            }
+
+            // Collect message attachments
+            let files = message
+                .attachments
+                .as_ref()
+                .map(|attachments| attachments.iter().map(|x| x.id.to_string()).collect())
+                .unwrap_or_default();
+
+            // Collect prior context
+            let prior_context = db
+                .fetch_messages(MessageQuery {
+                    filter: MessageFilter {
+                        channel: Some(message.channel.to_string()),
+                        ..Default::default()
+                    },
+                    limit: Some(15),
+                    time_period: MessageTimePeriod::Absolute {
+                        before: Some(message.id.to_string()),
+                        after: None,
+                        sort: Some(MessageSort::Latest),
+                    },
+                })
+                .await?;
+
+            // Collect leading context
+            let leading_context = db
+                .fetch_messages(MessageQuery {
+                    filter: MessageFilter {
+                        channel: Some(message.channel.to_string()),
+                        ..Default::default()
+                    },
+                    limit: Some(15),
+                    time_period: MessageTimePeriod::Absolute {
+                        before: None,
+                        after: Some(message.id.to_string()),
+                        sort: Some(MessageSort::Oldest),
+                    },
+                })
+                .await?;
+
+            (
+                SnapshotContent::Message {
+                    message,
+                    prior_context,
+                    leading_context,
+                },
+                files,
+            )
+        }
+        ReportedContent::Server { id, .. } => {
+            let server = db.fetch_server(id).await?;
+
+            // Users cannot report their own server
+            if server.owner == user.id {
+                return Err(Error::CannotReportYourself);
+            }
+
+            // Collect server's icon and banner
+            let files = [&server.icon, &server.banner]
+                .iter()
+                .filter_map(|x| x.as_ref().map(|x| x.id.to_string()))
+                .collect();
+
+            (SnapshotContent::Server(server), files)
+        }
+        ReportedContent::User { id, .. } => {
+            let reported_user = db.fetch_user(id).await?;
+
+            // Users cannot report themselves
+            if reported_user.id == user.id {
+                return Err(Error::CannotReportYourself);
+            }
+
+            // Collect user's avatar and profile background
+            let files = [
+                reported_user.avatar.as_ref(),
+                reported_user
+                    .profile
+                    .as_ref()
+                    .and_then(|profile| profile.background.as_ref()),
+            ]
+            .iter()
+            .filter_map(|x| x.as_ref().map(|x| x.id.to_string()))
+            .collect();
+
+            (SnapshotContent::User(reported_user), files)
+        }
+    };
+
+    // Mark all the attachments as reported
+    for file in files {
+        db.mark_attachment_as_reported(&file).await?;
+    }
+
+    // Generate an id for the report
+    let id = Ulid::new().to_string();
+
+    // Save a snapshot of the content
+    let snapshot = Snapshot {
+        id: Ulid::new().to_string(),
+        report_id: id.to_string(),
+        content,
+    };
+
+    db.insert_snapshot(&snapshot).await?;
+
+    // Save the report
+    let report = Report {
+        id,
+        author_id: user.id,
+        content: data.content,
+        additional_context: data.additional_context,
+        status: ReportStatus::Created {},
+        notes: String::new(),
+    };
+
+    db.insert_report(&report).await?;
+
+    EventV1::ReportCreate(report).global().await;
+
+    Ok(())
+}

crates/delta/src/routes/servers/ban_create.rs

@@ -1,5 +1,5 @@
 use revolt_quark::{
-    models::{ServerBan, User},
+    models::{server_member::MemberCompositeKey, ServerBan, User},
     perms, Db, Error, Permission, Ref, Result,
 };
 
@@ -47,13 +47,27 @@ pub async fn req(
         .throw_permission(db, Permission::BanMembers)
         .await?;
 
-    let member = target.as_member(db, &server.id).await?;
+    // If member exists, check privileges against them
+    if let Ok(member) = target.as_member(db, &server.id).await {
+        if member.get_ranking(permissions.server.get().unwrap())
+            <= permissions.get_member_rank().unwrap_or(i64::MIN)
+        {
+            return Err(Error::NotElevated);
+        }
 
-    if member.get_ranking(permissions.server.get().unwrap())
-        <= permissions.get_member_rank().unwrap_or(i64::MIN)
-    {
-        return Err(Error::NotElevated);
+        server.ban_member(db, member, data.reason).await.map(Json)
+    } else {
+        let server_id = server.id.to_string();
+        server
+            .ban_user(
+                db,
+                MemberCompositeKey {
+                    server: server_id,
+                    user: target.id,
+                },
+                data.reason,
+            )
+            .await
+            .map(Json)
     }
-
-    server.ban_member(db, member, data.reason).await.map(Json)
 }

crates/delta/src/routes/servers/channel_create.rs

@@ -11,20 +11,15 @@ use ulid::Ulid;
 use validator::Validate;
 
 /// # Channel Type
-#[derive(Serialize, Deserialize, JsonSchema)]
+#[derive(Serialize, Deserialize, JsonSchema, Default)]
 enum ChannelType {
     /// Text Channel
+    #[default]
     Text,
     /// Voice Channel
     Voice,
 }
 
-impl Default for ChannelType {
-    fn default() -> Self {
-        ChannelType::Text
-    }
-}
-
 /// # Channel Data
 #[derive(Validate, Serialize, Deserialize, JsonSchema)]
 pub struct DataCreateChannel {

crates/delta/src/routes/servers/emoji_list.rs

@@ -0,0 +1,17 @@
+use revolt_quark::models::{Emoji, User};
+use revolt_quark::{perms, Db, Ref, Result};
+
+use rocket::serde::json::Json;
+
+/// # Fetch Server Emoji
+///
+/// Fetch all emoji on a server.
+#[openapi(tag = "Server Customisation")]
+#[get("/<target>/emojis")]
+pub async fn list_emoji(db: &Db, user: User, target: Ref) -> Result<Json<Vec<Emoji>>> {
+    let server = target.as_server(db).await?;
+    perms(&user).server(&server).calc(db).await?;
+
+    // Fetch all emoji from server if we can view it
+    db.fetch_emoji_by_parent_id(&server.id).await.map(Json)
+}

crates/delta/src/routes/servers/member_edit.rs

@@ -1,9 +1,11 @@
+use std::collections::HashSet;
+
 use revolt_quark::{
     models::{
         server_member::{FieldsMember, PartialMember},
         File, Member, User,
     },
-    perms, Db, Error, Ref, Result,
+    perms, Db, Error, Permission, Ref, Result, Timestamp,
 };
 
 use rocket::serde::json::Json;
@@ -20,6 +22,8 @@ pub struct DataMemberEdit {
     avatar: Option<String>,
     /// Array of role ids
     roles: Option<Vec<String>>,
+    /// Timestamp this member is timed out until
+    timeout: Option<Timestamp>,
     /// Fields to remove from channel object
     #[validate(length(min = 1))]
     remove: Option<Vec<FieldsMember>>,
@@ -41,27 +45,110 @@ pub async fn req(
     data.validate()
         .map_err(|error| Error::FailedValidation { error })?;
 
-    let server = server.as_server(db).await?;
-    perms(&user).server(&server).calc(db).await?;
-
+    // Fetch server, target member and current permissions
+    let mut server = server.as_server(db).await?;
     let mut member = target.as_member(db, &server.id).await?;
+    let mut permissions = perms(&user).server(&server);
 
+    // Check permissions in server
+    let mut required = vec![];
+
+    if data.nickname.is_some()
+        || data
+            .remove
+            .as_ref()
+            .map(|x| x.contains(&FieldsMember::Nickname))
+            .unwrap_or_default()
+    {
+        if user.id == member.id.user {
+            required.push(Permission::ChangeNickname);
+        } else {
+            required.push(Permission::ManageNicknames);
+        }
+    }
+
+    if data.avatar.is_some()
+        || data
+            .remove
+            .as_ref()
+            .map(|x| x.contains(&FieldsMember::Avatar))
+            .unwrap_or_default()
+    {
+        if user.id == member.id.user {
+            required.push(Permission::ChangeAvatar);
+        } else {
+            return Err(Error::InvalidOperation);
+        }
+    }
+
+    if data.roles.is_some()
+        || data
+            .remove
+            .as_ref()
+            .map(|x| x.contains(&FieldsMember::Roles))
+            .unwrap_or_default()
+    {
+        required.push(Permission::AssignRoles);
+    }
+
+    if data.timeout.is_some()
+        || data
+            .remove
+            .as_ref()
+            .map(|x| x.contains(&FieldsMember::Timeout))
+            .unwrap_or_default()
+    {
+        required.push(Permission::TimeoutMembers);
+    }
+
+    for permission in required {
+        permissions.throw_permission(db, permission).await?;
+    }
+
+    // Resolve our ranking
+    let our_ranking = permissions.get_member_rank().unwrap_or(i64::MIN);
+
+    // Check that we have permissions to act against this member
+    if member.id.user != user.id
+        && member.get_ranking(permissions.server.get().unwrap()) <= our_ranking
+    {
+        return Err(Error::NotElevated);
+    }
+
+    // Check permissions against roles in diff
+    if let Some(roles) = &data.roles {
+        let current_roles = member.roles.iter().collect::<HashSet<&String>>();
+
+        let new_roles = roles.iter().collect::<HashSet<&String>>();
+        let added_roles: Vec<&&String> = new_roles.difference(&current_roles).collect();
+
+        for role_id in added_roles {
+            if let Some(role) = server.roles.remove(*role_id) {
+                if role.rank <= our_ranking {
+                    return Err(Error::NotElevated);
+                }
+            } else {
+                return Err(Error::InvalidRole);
+            }
+        }
+    }
+
+    // Apply edits to the member object
     let DataMemberEdit {
         nickname,
         avatar,
         roles,
+        timeout,
         remove,
     } = data;
 
     let mut partial = PartialMember {
         nickname,
         roles,
+        timeout,
         ..Default::default()
     };
 
-    // ! FIXME: calculate permission against member
-    // ! FIXME: also check roles exist lol
-
     // 1. Remove fields from object
     if let Some(fields) = &remove {
         if fields.contains(&FieldsMember::Avatar) {

crates/delta/src/routes/servers/member_fetch_all.rs

@@ -1,8 +1,6 @@
 use revolt_quark::{
     models::{Member, User},
-    perms,
-    presence::presence_filter_online,
-    Db, Ref, Result,
+    perms, Db, Ref, Result,
 };
 
 use rocket::serde::json::Json;
@@ -47,16 +45,7 @@ pub async fn req(
         user_ids.push(member.id.user.clone());
     }
 
-    let online_ids = presence_filter_online(&user_ids).await;
-    let mut users = db
-        .fetch_users(&user_ids)
-        .await?
-        .into_iter()
-        .map(|mut user| {
-            user.online = Some(online_ids.contains(&user.id));
-            user.foreign()
-        })
-        .collect::<Vec<User>>();
+    let mut users = User::fetch_foreign_users(db, &user_ids).await?;
 
     // Ensure the lists match up exactly.
     members.sort_by(|a, b| a.id.user.cmp(&b.id.user));

crates/delta/src/routes/servers/member_remove.rs

@@ -34,7 +34,7 @@ pub async fn req(db: &Db, user: User, target: Ref, member: Ref) -> Result<EmptyR
     }
 
     server
-        .remove_member(db, member, RemovalIntention::Kick)
+        .remove_member(db, member, RemovalIntention::Kick, false)
         .await
         .map(|_| EmptyResponse)
 }

crates/delta/src/routes/servers/mod.rs

@@ -1,30 +1,26 @@
+use revolt_rocket_okapi::revolt_okapi::openapi3::OpenApi;
 use rocket::Route;
-use rocket_okapi::okapi::openapi3::OpenApi;
-
-mod server_ack;
-mod server_create;
-mod server_delete;
-mod server_edit;
-mod server_fetch;
-
-mod channel_create;
-
-mod member_edit;
-mod member_fetch;
-mod member_fetch_all;
-mod member_remove;
 
 mod ban_create;
 mod ban_list;
 mod ban_remove;
-
+mod channel_create;
+mod emoji_list;
 mod invites_fetch;
-
+mod member_edit;
+mod member_fetch;
+mod member_fetch_all;
+mod member_remove;
 mod permissions_set;
 mod permissions_set_default;
 mod roles_create;
 mod roles_delete;
 mod roles_edit;
+mod server_ack;
+mod server_create;
+mod server_delete;
+mod server_edit;
+mod server_fetch;
 
 pub fn routes() -> (Vec<Route>, OpenApi) {
     openapi_get_routes_spec![
@@ -46,6 +42,7 @@ pub fn routes() -> (Vec<Route>, OpenApi) {
         roles_edit::req,
         roles_delete::req,
         permissions_set::req,
-        permissions_set_default::req
+        permissions_set_default::req,
+        emoji_list::list_emoji
     ]
 }

crates/delta/src/routes/servers/roles_edit.rs

@@ -3,7 +3,9 @@ use revolt_quark::{
         server::{FieldsRole, PartialRole, Role},
         User,
     },
-    perms, Db, Error, Permission, Ref, Result,
+    perms,
+    util::regex::RE_COLOUR,
+    Db, Error, Permission, Ref, Result,
 };
 
 use rocket::serde::json::Json;
@@ -17,7 +19,7 @@ pub struct DataEditRole {
     #[validate(length(min = 1, max = 32))]
     name: Option<String>,
     /// Role colour
-    #[validate(length(min = 1, max = 32))]
+    #[validate(length(min = 1, max = 128), regex = "RE_COLOUR")]
     colour: Option<String>,
     /// Whether this role should be displayed separately
     hoist: Option<bool>,

crates/delta/src/routes/servers/server_delete.rs

@@ -2,13 +2,27 @@ use revolt_quark::{
     models::{server_member::RemovalIntention, User},
     Db, EmptyResponse, Ref, Result,
 };
+use serde::{Deserialize, Serialize};
+use validator::Validate;
+
+/// # Query Parameters
+#[derive(Validate, Serialize, Deserialize, JsonSchema, FromForm)]
+pub struct OptionsServerDelete {
+    /// Whether to not send a leave message
+    leave_silently: Option<bool>,
+}
 
 /// # Delete / Leave Server
 ///
 /// Deletes a server if owner otherwise leaves.
 #[openapi(tag = "Server Information")]
-#[delete("/<target>")]
-pub async fn req(db: &Db, user: User, target: Ref) -> Result<EmptyResponse> {
+#[delete("/<target>?<options..>")]
+pub async fn req(
+    db: &Db,
+    user: User,
+    target: Ref,
+    options: OptionsServerDelete,
+) -> Result<EmptyResponse> {
     let server = target.as_server(db).await?;
     let member = db.fetch_member(&target.id, &user.id).await?;
 
@@ -16,7 +30,12 @@ pub async fn req(db: &Db, user: User, target: Ref) -> Result<EmptyResponse> {
         server.delete(db).await
     } else {
         server
-            .remove_member(db, member, RemovalIntention::Leave)
+            .remove_member(
+                db,
+                member,
+                RemovalIntention::Leave,
+                options.leave_silently.unwrap_or_default(),
+            )
             .await
     }
     .map(|_| EmptyResponse)

crates/delta/src/routes/servers/server_edit.rs

@@ -1,3 +1,5 @@
+use std::collections::HashSet;
+
 use revolt_quark::{
     models::{
         server::{Category, FieldsServer, PartialServer, SystemMessageChannels},
@@ -31,8 +33,14 @@ pub struct DataEditServer {
     /// System message configuration
     system_messages: Option<SystemMessageChannels>,
 
+    /// Bitfield of server flags
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub flags: Option<i32>,
+
     // Whether this server is age-restricted
     // nsfw: Option<bool>,
+    /// Whether this server is public and should show up on [Revolt Discover](https://rvlt.gg)
+    discoverable: Option<bool>,
     /// Whether analytics should be collected for this server
     ///
     /// Must be enabled in order to show up on [Revolt Discover](https://rvlt.gg).
@@ -88,6 +96,11 @@ pub async fn req(
             .await?;
     }
 
+    // Check we are privileged if changing sensitive fields
+    if data.flags.is_some() && !user.privileged {
+        return Err(Error::NotPrivileged);
+    }
+
     if data.categories.is_some() {
         permissions
             .throw_permission(db, Permission::ManageChannel)
@@ -101,7 +114,9 @@ pub async fn req(
         banner,
         categories,
         system_messages,
+        flags,
         // nsfw,
+        discoverable,
         analytics,
         remove,
     } = data;
@@ -111,7 +126,9 @@ pub async fn req(
         description,
         categories,
         system_messages,
+        flags,
         // nsfw,
+        discoverable,
         analytics,
         ..Default::default()
     };
@@ -131,29 +148,44 @@ pub async fn req(
         }
     }
 
-    // 2. Apply new icon
+    // 2. Validate changes
+    if let Some(system_messages) = &partial.system_messages {
+        for id in system_messages.clone().into_channel_ids() {
+            if !server.channels.contains(&id) {
+                return Err(Error::NotFound);
+            }
+        }
+    }
+
+    if let Some(categories) = &mut partial.categories {
+        let mut channel_ids = HashSet::new();
+        for category in categories {
+            for channel in &category.channels {
+                if channel_ids.contains(channel) {
+                    return Err(Error::InvalidOperation);
+                }
+
+                channel_ids.insert(channel.to_string());
+            }
+
+            category
+                .channels
+                .retain(|item| server.channels.contains(item));
+        }
+    }
+
+    // 3. Apply new icon
     if let Some(icon) = icon {
         partial.icon = Some(File::use_server_icon(db, &icon, &server.id).await?);
         server.icon = partial.icon.clone();
     }
 
-    // 3. Apply new banner
+    // 4. Apply new banner
     if let Some(banner) = banner {
         partial.banner = Some(File::use_banner(db, &banner, &server.id).await?);
         server.banner = partial.banner.clone();
     }
 
-    // 4. Validate changes
-    if let Some(system_messages) = &partial.system_messages {
-        let channels = system_messages.clone().into_channel_ids();
-        if !db
-            .check_channels_exist(&channels.into_iter().collect())
-            .await?
-        {
-            return Err(Error::NotFound);
-        }
-    }
-
     server
         .update(db, partial, remove.unwrap_or_default())
         .await?;

crates/delta/src/routes/sync/mod.rs

@@ -1,5 +1,5 @@
+use revolt_rocket_okapi::revolt_okapi::openapi3::OpenApi;
 use rocket::Route;
-use rocket_okapi::okapi::openapi3::OpenApi;
 
 mod get_settings;
 mod get_unreads;

crates/delta/src/routes/sync/set_settings.rs

@@ -1,5 +1,5 @@
 use revolt_quark::models::User;
-use revolt_quark::r#impl::generic::users::user_settings::UserSettingsImpl;
+use revolt_quark::r#impl::UserSettingsImpl;
 use revolt_quark::{Db, EmptyResponse, Result};
 
 use chrono::prelude::*;

crates/delta/src/routes/users/add_friend.rs

@@ -1,16 +1,16 @@
 use revolt_quark::models::User;
-use revolt_quark::{Database, Error, Result};
+use revolt_quark::{Database, Error, Ref, Result};
 
 use rocket::serde::json::Json;
 use rocket::State;
 
-/// # Send Friend Request / Accept Request
+/// # Accept Friend Request
 ///
-/// Send a friend request to another user or accept another user's friend request.
+/// Accept another user's friend request.
 #[openapi(tag = "Relationships")]
-#[put("/<username>/friend")]
-pub async fn req(db: &State<Database>, user: User, username: String) -> Result<Json<User>> {
-    let mut target = db.fetch_user_by_username(&username).await?;
+#[put("/<target>/friend")]
+pub async fn req(db: &State<Database>, user: User, target: Ref) -> Result<Json<User>> {
+    let mut target = target.as_user(db).await?;
 
     if user.bot.is_some() || target.bot.is_some() {
         return Err(Error::IsBot);

crates/delta/src/routes/users/change_username.rs

@@ -1,6 +1,5 @@
 use crate::util::regex::RE_USERNAME;
-use rauth::entities::Account;
-use revolt_quark::{models::User, Database, Error, Result};
+use revolt_quark::{authifier::models::Account, models::User, Database, Error, Result};
 use rocket::{serde::json::Json, State};
 use serde::{Deserialize, Serialize};
 use validator::Validate;

crates/delta/src/routes/users/edit_user.rs

@@ -1,6 +1,6 @@
 use revolt_quark::models::user::{FieldsUser, PartialUser, User};
 use revolt_quark::models::File;
-use revolt_quark::{Database, Error, Result};
+use revolt_quark::{Database, Error, Ref, Result};
 
 use revolt_quark::models::user::UserStatus;
 use rocket::serde::json::Json;
@@ -24,6 +24,10 @@ pub struct UserProfileData {
 /// # User Data
 #[derive(Validate, Serialize, Deserialize, JsonSchema)]
 pub struct DataEditUser {
+    /// Attachment Id for avatar
+    #[validate(length(min = 1, max = 128))]
+    avatar: Option<String>,
+
     /// New user status
     #[validate]
     status: Option<UserStatus>,
@@ -32,9 +36,14 @@ pub struct DataEditUser {
     /// This is applied as a partial.
     #[validate]
     profile: Option<UserProfileData>,
-    /// Attachment Id for avatar
-    #[validate(length(min = 1, max = 128))]
-    avatar: Option<String>,
+
+    /// Bitfield of user badges
+    #[serde(skip_serializing_if = "Option::is_none")]
+    badges: Option<i32>,
+    /// Enum of user flags
+    #[serde(skip_serializing_if = "Option::is_none")]
+    flags: Option<i32>,
+
     /// Fields to remove from user object
     #[validate(length(min = 1))]
     remove: Option<Vec<FieldsUser>>,
@@ -44,19 +53,36 @@ pub struct DataEditUser {
 ///
 /// Edit currently authenticated user.
 #[openapi(tag = "User Information")]
-#[patch("/@me", data = "<data>")]
+#[patch("/<target>", data = "<data>")]
 pub async fn req(
     db: &State<Database>,
     mut user: User,
+    target: Ref,
     data: Json<DataEditUser>,
 ) -> Result<Json<User>> {
     let data = data.into_inner();
     data.validate()
         .map_err(|error| Error::FailedValidation { error })?;
 
+    // If we want to edit a different user than self, ensure we have
+    // permissions and subsequently replace the user in question
+    if target.id != "@me" {
+        if !user.privileged {
+            return Err(Error::NotPrivileged);
+        }
+
+        user = target.as_user(db).await?;
+    // Otherwise, filter out invalid edit fields
+    } else if data.badges.is_some() || data.flags.is_some() {
+        return Err(Error::NotPrivileged);
+    }
+
+    // Exit out early if nothing is changed
     if data.status.is_none()
         && data.profile.is_none()
         && data.avatar.is_none()
+        && data.badges.is_none()
+        && data.flags.is_none()
         && data.remove.is_none()
     {
         return Ok(Json(user));
@@ -83,7 +109,11 @@ pub async fn req(
         }
     }
 
-    let mut partial: PartialUser = Default::default();
+    let mut partial: PartialUser = PartialUser {
+        badges: data.badges,
+        flags: data.flags,
+        ..Default::default()
+    };
 
     // 2. Apply new avatar
     if let Some(avatar) = data.avatar {

crates/delta/src/routes/users/fetch_user_flags.rs

@@ -0,0 +1,26 @@
+use revolt_quark::{Database, Ref, Result};
+
+use rocket::{serde::json::Json, State};
+use serde::Serialize;
+
+/// # Flag Response
+#[derive(Serialize, JsonSchema)]
+pub struct FlagResponse {
+    /// Flags
+    flags: i32,
+}
+
+/// # Fetch User Flags
+///
+/// Retrieve a user's flags.
+#[openapi(tag = "User Information")]
+#[get("/<target>/flags")]
+pub async fn fetch_user_flags(db: &State<Database>, target: Ref) -> Result<Json<FlagResponse>> {
+    let flags = if let Ok(target) = target.as_user(db).await {
+        target.flags.unwrap_or_default()
+    } else {
+        0
+    };
+
+    Ok(Json(FlagResponse { flags }))
+}

crates/delta/src/routes/users/get_default_avatar.rs

@@ -1,7 +1,7 @@
+use revolt_rocket_okapi::revolt_okapi::openapi3::{self, MediaType, RefOr};
 use rocket::http::ContentType;
 use rocket::response::{self, Responder};
 use rocket::{Request, Response};
-use rocket_okapi::okapi::openapi3::{self, MediaType, RefOr};
 use schemars::schema::{InstanceType, SchemaObject, SingleOrVec};
 
 pub struct CachedFile((ContentType, Vec<u8>));
@@ -16,10 +16,10 @@ impl<'r> Responder<'r, 'static> for CachedFile {
     }
 }
 
-impl rocket_okapi::response::OpenApiResponderInner for CachedFile {
+impl revolt_rocket_okapi::response::OpenApiResponderInner for CachedFile {
     fn responses(
-        _gen: &mut rocket_okapi::gen::OpenApiGenerator,
-    ) -> std::result::Result<openapi3::Responses, rocket_okapi::OpenApiError> {
+        _gen: &mut revolt_rocket_okapi::gen::OpenApiGenerator,
+    ) -> std::result::Result<openapi3::Responses, revolt_rocket_okapi::OpenApiError> {
         let mut responses = schemars::Map::new();
         let mut content = schemars::Map::new();
 
@@ -59,18 +59,6 @@ impl rocket_okapi::response::OpenApiResponderInner for CachedFile {
 pub async fn req(target: String) -> CachedFile {
     CachedFile((
         ContentType::PNG,
-        match target.chars().last().unwrap() {
-            // 0123456789ABCDEFGHJKMNPQRSTVWXYZ
-            '0' | '1' | '2' | '3' | 'S' | 'Z' => {
-                include_bytes!(crate::asset!("user/2.png")).to_vec()
-            }
-            '4' | '5' | '6' | '7' | 'T' => include_bytes!(crate::asset!("user/3.png")).to_vec(),
-            '8' | '9' | 'A' | 'B' => include_bytes!(crate::asset!("user/4.png")).to_vec(),
-            'C' | 'D' | 'E' | 'F' | 'V' => include_bytes!(crate::asset!("user/5.png")).to_vec(),
-            'G' | 'H' | 'J' | 'K' | 'W' => include_bytes!(crate::asset!("user/6.png")).to_vec(),
-            'M' | 'N' | 'P' | 'Q' | 'X' => include_bytes!(crate::asset!("user/7.png")).to_vec(),
-            /*'0' | '1' | '2' | '3' | 'R' | 'Y'*/
-            _ => include_bytes!(crate::asset!("user/1.png")).to_vec(),
-        },
+        revolt_quark::util::pfp::avatar(target.chars().last().unwrap()),
     ))
 }

crates/delta/src/routes/users/mod.rs

@@ -1,5 +1,5 @@
+use revolt_rocket_okapi::revolt_okapi::openapi3::OpenApi;
 use rocket::Route;
-use rocket_okapi::okapi::openapi3::OpenApi;
 
 mod add_friend;
 mod block_user;
@@ -9,10 +9,12 @@ mod fetch_dms;
 mod fetch_profile;
 mod fetch_self;
 mod fetch_user;
+mod fetch_user_flags;
 mod find_mutual;
 mod get_default_avatar;
 mod open_dm;
 mod remove_friend;
+mod send_friend_request;
 mod unblock_user;
 
 pub fn routes() -> (Vec<Route>, OpenApi) {
@@ -20,6 +22,7 @@ pub fn routes() -> (Vec<Route>, OpenApi) {
         // User Information
         fetch_self::req,
         fetch_user::req,
+        fetch_user_flags::fetch_user_flags,
         edit_user::req,
         change_username::req,
         get_default_avatar::req,
@@ -33,5 +36,6 @@ pub fn routes() -> (Vec<Route>, OpenApi) {
         remove_friend::req,
         block_user::req,
         unblock_user::req,
+        send_friend_request::req,
     ]
 }

crates/delta/src/routes/users/send_friend_request.rs

@@ -0,0 +1,32 @@
+use revolt_quark::models::User;
+use revolt_quark::{Database, Error, Result};
+
+use rocket::serde::json::Json;
+use rocket::State;
+use serde::{Deserialize, Serialize};
+
+/// # User Lookup Information
+#[derive(Serialize, Deserialize, JsonSchema)]
+pub struct DataSendFriendRequest {
+    username: String,
+}
+
+/// # Send Friend Request
+///
+/// Send a friend request to another user.
+#[openapi(tag = "Relationships")]
+#[post("/friend", data = "<data>")]
+pub async fn req(
+    db: &State<Database>,
+    user: User,
+    data: Json<DataSendFriendRequest>,
+) -> Result<Json<User>> {
+    let mut target = db.fetch_user_by_username(&data.username).await?;
+
+    if user.bot.is_some() || target.bot.is_some() {
+        return Err(Error::IsBot);
+    }
+
+    user.add_friend(db, &mut target).await?;
+    Ok(Json(target.with_auto_perspective(db, &user).await))
+}

crates/delta/src/util/mod.rs

@@ -1,3 +1 @@
-pub mod idempotency;
-pub mod ratelimiter;
 pub mod regex;

crates/delta/src/util/regex.rs

@@ -6,4 +6,9 @@ use regex::Regex;
 /// Block zero width space
 /// Block lookalike characters
 pub static RE_USERNAME: Lazy<Regex> =
-    Lazy::new(|| Regex::new(r"^[^\u200BА-Яа-яΑ-Ωα-ω]+$").unwrap());
+    Lazy::new(|| Regex::new(r"^[^\u200BА-Яа-яΑ-Ωα-ω@#:\n\r\[\]]+$").unwrap());
+
+/// Regex for valid emoji names
+///
+/// Alphanumeric and underscores
+pub static RE_EMOJI: Lazy<Regex> = Lazy::new(|| Regex::new(r"^[a-z0-9_]+$").unwrap());

crates/delta/src/version.rs

@@ -1 +0,0 @@
-pub const VERSION: &str = "0.5.3-5-patch.2";

crates/quark/.github/FUNDING.yml

@@ -1,2 +0,0 @@
-ko_fi: insertish
-custom: https://insrt.uk/donate

crates/quark/.github/workflows/rust.yaml

@@ -1,33 +0,0 @@
-name: Rust build and test
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-env:
-  CARGO_TERM_COLOR: always
-
-jobs:
-  check:
-    name: Rust project
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - name: Install latest nightly
-        uses: actions-rs/toolchain@v1
-        with:
-            toolchain: nightly
-            override: true
-            components: rustfmt, clippy
-
-      - name: Run cargo build
-        uses: actions-rs/cargo@v1
-        with:
-          command: build
-      
-      - name: Run cargo test
-        uses: actions-rs/cargo@v1
-        with:
-          command: test

crates/quark/.github/workflows/triage_issue.yml

@@ -1,49 +0,0 @@
-name: Add Issue to Board
-
-on:
-  issues:
-    types: [opened]
-
-jobs:
-  track_issue:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get project data
-        env:
-          GITHUB_TOKEN: ${{ secrets.PAT }}
-        run: |
-          gh api graphql -f query='
-            query {
-              organization(login: "revoltchat"){
-                projectNext(number: 3) {
-                  id
-                  fields(first:20) {
-                    nodes {
-                      id
-                      name
-                      settings
-                    }
-                  }
-                }
-              }
-            }' > project_data.json
-
-          echo 'PROJECT_ID='$(jq '.data.organization.projectNext.id' project_data.json) >> $GITHUB_ENV
-          echo 'STATUS_FIELD_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") | .id' project_data.json) >> $GITHUB_ENV
-          echo 'TODO_OPTION_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") |.settings | fromjson.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!) {
-              addProjectNextItem(input: {projectId: $project, contentId: $issue}) {
-                projectNextItem {
-                  id
-                }
-              }
-            }' -f project=$PROJECT_ID -f issue=$ISSUE_ID --jq '.data.addProjectNextItem.projectNextItem.id')"
-          
-          echo 'ITEM_ID='$item_id >> $GITHUB_ENV

crates/quark/.github/workflows/triage_pr.yml

@@ -1,72 +0,0 @@
-name: Add PR to Board
-
-on:
-  pull_request_target:
-    types: [opened, synchronize, ready_for_review, review_requested]
-
-jobs:
-  track_pr:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Get project data
-        env:
-          GITHUB_TOKEN: ${{ secrets.PAT }}
-        run: |
-          gh api graphql -f query='
-            query {
-              organization(login: "revoltchat"){
-                projectNext(number: 3) {
-                  id
-                  fields(first:20) {
-                    nodes {
-                      id
-                      name
-                      settings
-                    }
-                  }
-                }
-              }
-            }' > project_data.json
-
-          echo 'PROJECT_ID='$(jq '.data.organization.projectNext.id' project_data.json) >> $GITHUB_ENV
-          echo 'STATUS_FIELD_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") | .id' project_data.json) >> $GITHUB_ENV
-          echo 'INCOMING_OPTION_ID='$(jq '.data.organization.projectNext.fields.nodes[] | select(.name== "Status") |.settings | fromjson.options[] | select(.name=="Incoming PRs") |.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!) {
-              addProjectNextItem(input: {projectId: $project, contentId: $pr}) {
-                projectNextItem {
-                  id
-                }
-              }
-            }' -f project=$PROJECT_ID -f pr=$PR_ID --jq '.data.addProjectNextItem.projectNextItem.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: updateProjectNextItemField(input: {
-                projectId: $project
-                itemId: $item
-                fieldId: $status_field
-                value: $status_value
-              }) {
-                projectNextItem {
-                  id
-                  }
-              }
-            }' -f project=$PROJECT_ID -f item=$ITEM_ID -f status_field=$STATUS_FIELD_ID -f status_value=${{ env.INCOMING_OPTION_ID }} --silent

crates/quark/Cargo.toml

@@ -1,14 +1,27 @@
 [package]
 name = "revolt-quark"
-version = "0.1.0"
+version = "0.5.17"
+license = "AGPL-3.0-or-later"
 edition = "2021"
 
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [features]
 mongo = [ "mongodb" ]
-rocket_impl = [ "rocket" ]
-test = [ "async-std", "mongo", "mongodb/async-std-runtime", "rocket_impl", "rauth" ]
+rocket_impl = [
+    "rocket",
+    "rocket_empty",
+    "rocket_cors",
+
+    "lru",
+    "dashmap",
+
+    "authifier/database-mongodb",
+    "authifier/rocket_impl",
+    "authifier/okapi_impl"
+]
+
+test = [ "async-std", "mongo", "mongodb/async-std-runtime", "rocket_impl" ]
 default = [ "test" ]
 
 [dependencies]
@@ -16,7 +29,7 @@ default = [ "test" ]
 serde = { version = "1", features = ["derive"] }
 validator = { version = "0.14", features = ["derive"] }
 iso8601-timestamp = { version = "0.1.8", features = ["schema", "bson"] }
-optional_struct = { git = "https://github.com/insertish/OptionalStruct", rev = "e275d2726595474632485934aa0887fa52281f70" }
+optional_struct = { git = "https://github.com/insertish/OptionalStruct", rev = "ee56427cee1f007839825d93d07fffd5a5e038c7" }
 
 # Formats
 bincode = "1.3.3"
@@ -25,10 +38,8 @@ bson = { version = "2.1.0", features = ["chrono-0_4"] }
 
 # Spec Generation
 schemars = "0.8.8"
-okapi = { git = "https://github.com/insertish/okapi", rev = "dcf0df115596ee07a587a7a543cddf3d7944645b" }
-rocket_okapi = { git = "https://github.com/insertish/okapi", rev = "dcf0df115596ee07a587a7a543cddf3d7944645b" }
-# okapi = "0.7.0-rc.1"
-# rocket_okapi = "0.8.0-rc.1"
+revolt_okapi = "0.9.1"
+revolt_rocket_okapi = { version = "0.9.1", features = [ "swagger" ] }
 
 # Databases
 redis-kiss = { version = "0.1.3" }
@@ -51,20 +62,29 @@ regex = "1.5.5"
 nanoid = "0.4.0"
 linkify = "0.8.1"
 dotenv = "0.15.0"
+indexmap = "1.9.1"
 impl_ops = "0.1.1"
 num_enum = "0.5.6"
 reqwest = "0.11.10"
 bitfield = "0.13.2"
-lazy_static = "1.4.0"
+once_cell = "1.17.1"
+async-lock = "2.6.0"
+
+lru = { version = "0.7.6", optional = true }
+dashmap = { version = "5.2.0", optional = true }
 
 # Web Push
 base64 = "0.13.0"
 web-push = "0.7.2"
 
 # Implementations
-rauth = { optional = true, git = "https://github.com/insertish/rauth", rev = "001a9698c56cea79e69e4ae71d7bc2cb48aec1a6" }
-rocket = { optional = true, version = "=0.5.0-rc.1", default-features = false, features = ["json"] }
-rocket_http = { optional = true, version = "=0.5.0-rc.1" }
+rocket_http = { optional = true, version = "0.5.0-rc.2" }
+rocket = { optional = true, version = "0.5.0-rc.2", default-features = false, features = ["json"] }
+rocket_empty = { version = "0.1.1", optional = true, features = [ "schema" ] }
+rocket_cors = { optional = true, git = "https://github.com/lawliet89/rocket_cors", rev = "c17e8145baa4790319fdb6a473e465b960f55e7c" }
+
+# Authifier
+authifier = { version = "1.0.7", features = [ "async-std-runtime" ] }
 
 # Sentry
 sentry = "0.25.0"

crates/quark/LICENSE

@@ -1,661 +0,0 @@
-                    GNU AFFERO GENERAL PUBLIC LICENSE
-                       Version 3, 19 November 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU Affero General Public License is a free, copyleft license for
-software and other kinds of works, specifically designed to ensure
-cooperation with the community in the case of network server software.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-our General Public Licenses are intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  Developers that use our General Public Licenses protect your rights
-with two steps: (1) assert copyright on the software, and (2) offer
-you this License which gives you legal permission to copy, distribute
-and/or modify the software.
-
-  A secondary benefit of defending all users' freedom is that
-improvements made in alternate versions of the program, if they
-receive widespread use, become available for other developers to
-incorporate.  Many developers of free software are heartened and
-encouraged by the resulting cooperation.  However, in the case of
-software used on network servers, this result may fail to come about.
-The GNU General Public License permits making a modified version and
-letting the public access it on a server without ever releasing its
-source code to the public.
-
-  The GNU Affero General Public License is designed specifically to
-ensure that, in such cases, the modified source code becomes available
-to the community.  It requires the operator of a network server to
-provide the source code of the modified version running there to the
-users of that server.  Therefore, public use of a modified version, on
-a publicly accessible server, gives the public access to the source
-code of the modified version.
-
-  An older license, called the Affero General Public License and
-published by Affero, was designed to accomplish similar goals.  This is
-a different license, not a version of the Affero GPL, but Affero has
-released a new version of the Affero GPL which permits relicensing under
-this license.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU Affero General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Remote Network Interaction; Use with the GNU General Public License.
-
-  Notwithstanding any other provision of this License, if you modify the
-Program, your modified version must prominently offer all users
-interacting with it remotely through a computer network (if your version
-supports such interaction) an opportunity to receive the Corresponding
-Source of your version by providing access to the Corresponding Source
-from a network server at no charge, through some standard or customary
-means of facilitating copying of software.  This Corresponding Source
-shall include the Corresponding Source for any work covered by version 3
-of the GNU General Public License that is incorporated pursuant to the
-following paragraph.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the work with which it is combined will remain governed by version
-3 of the GNU General Public License.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU Affero General Public License from time to time.  Such new versions
-will be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU Affero General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU Affero General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU Affero General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    Revolt Quark
-    Copyright (C) 2022 Pawel Makles
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published
-    by the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If your software can interact with users remotely through a computer
-network, you should also make sure that it provides a way for users to
-get its source.  For example, if your program is a web application, its
-interface could display a "Source" link that leads users to an archive
-of the code.  There are many ways you could offer source, and different
-solutions will be better for different programs; see section 13 for the
-specific requirements.
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU AGPL, see
-<https://www.gnu.org/licenses/>.

crates/quark/LICENSE

@@ -0,0 +1 @@
+../../LICENSE