feat: enable 2FA login

closes #159

.dockerignore

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

.env

@@ -0,0 +1,79 @@
+# MongoDB URI
+MONGODB=mongodb://localhost
+
+# URL to where the Revolt app is publicly accessible
+REVOLT_APP_URL=http://local.revolt.chat:5000
+
+# URL to where the API is publicly accessible
+REVOLT_PUBLIC_URL=http://local.revolt.chat:8000
+VITE_API_URL=http://local.revolt.chat:8000
+
+# URL to where the WebSocket server is publicly accessible
+REVOLT_EXTERNAL_WS_URL=ws://local.revolt.chat:9000
+
+# URL to where Autumn is publicly available
+AUTUMN_PUBLIC_URL=http://local.revolt.chat:3000
+
+# URL to where January is publicly available
+JANUARY_PUBLIC_URL=http://local.revolt.chat:7000
+
+# URL to where Vortex is publicly available
+# VOSO_PUBLIC_URL=https://voso.revolt.chat
+
+
+##
+## hCaptcha Settings
+##
+
+# If you are sure that you don't want to use hCaptcha, set to 1.
+REVOLT_UNSAFE_NO_CAPTCHA=1
+
+# hCaptcha API key
+# REVOLT_HCAPTCHA_KEY=0x0000000000000000000000000000000000000000
+
+# hCaptcha site key
+# REVOLT_HCAPTCHA_SITEKEY=10000000-ffff-ffff-ffff-000000000001
+
+
+##
+## Email Settings
+##
+
+# If you are sure that you don't want to use email verification, set to 1.
+REVOLT_UNSAFE_NO_EMAIL=1
+
+# SMTP host
+# REVOLT_SMTP_HOST=smtp.example.com
+
+# SMTP username
+# REVOLT_SMTP_USERNAME=noreply@example.com
+
+# SMTP password
+# REVOLT_SMTP_PASSWORD=CHANGEME
+
+# SMTP From header
+# REVOLT_SMTP_FROM=Revolt <noreply@example.com>
+
+
+##
+## Application Settings
+##
+
+# Whether to only allow users to sign up if they have an invite code
+REVOLT_INVITE_ONLY=0
+
+# Maximum number of people that can be in a group chat
+REVOLT_MAX_GROUP_SIZE=150
+
+# VAPID keys for push notifications
+# Generate using this guide: https://gitlab.insrt.uk/revolt/delta/-/wikis/vapid
+# --> Please replace these keys before going into production! <--
+REVOLT_VAPID_PRIVATE_KEY=LS0tLS1CRUdJTiBFQyBQUklWQVRFIEtFWS0tLS0tCk1IY0NBUUVFSUJSUWpyTWxLRnBiVWhsUHpUbERvcEliYk1yeVNrNXpKYzVYVzIxSjJDS3hvQW9HQ0NxR1NNNDkKQXdFSG9VUURRZ0FFWnkrQkg2TGJQZ2hEa3pEempXOG0rUXVPM3pCajRXT1phdkR6ZU00c0pqbmFwd1psTFE0WAp1ZDh2TzVodU94QWhMQlU3WWRldVovWHlBdFpWZmNyQi9BPT0KLS0tLS1FTkQgRUMgUFJJVkFURSBLRVktLS0tLQo=
+REVOLT_VAPID_PUBLIC_KEY=BGcvgR-i2z4IQ5Mw841vJvkLjt8wY-FjmWrw83jOLCY52qcGZS0OF7nfLzuYbjsQISwVO2HXrmf18gLWVX3Kwfw=
+
+
+##
+## Vortex configuration
+##
+
+# VOSO_MANAGE_TOKEN=CHANGEME

.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/docker.yml

@@ -1,103 +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: revoltchat/server, ghcr.io/revoltchat/server
-            - name: Login to DockerHub
-              uses: docker/login-action@v1
-              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 }}
-            - 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

.gitignore

@@ -1,8 +1,3 @@
 Rocket.toml
-/target
-/target_backup
-**/*.rs.bk
-.mongo
+target
 .data
-.env
-avatar.png

.vscode/launch.json

@@ -1,34 +0,0 @@
-{
-    "configurations": [
-        {
-            "name": "(gdb) Launch",
-            "type": "cppdbg",
-            "request": "launch",
-            "program": "${workspaceFolder}/target/debug/revolt",
-            "args": [],
-            "stopAtEntry": false,
-            "cwd": "${workspaceFolder}",
-            "environment": [{
-                "name": "ROCKET_ADDRESS",
-                "value": "0.0.0.0"
-            }, {
-                "name": "MONGODB",
-                "value": "mongodb://localhost"
-            }],
-            "externalConsole": false,
-            "MIMode": "gdb",
-            "setupCommands": [
-                {
-                    "description": "Enable pretty-printing for gdb",
-                    "text": "-enable-pretty-printing",
-                    "ignoreFailures": true
-                },
-                {
-                    "description":  "Set Disassembly Flavor to Intel",
-                    "text": "-gdb-set disassembly-flavor intel",
-                    "ignoreFailures": true
-                }
-            ]
-        }
-    ]
-}

Cargo.toml

@@ -1,68 +1,2 @@
-[package]
-name = "revolt"
-# To help optimise CI and Docker builds.
-# Version here is left as 0.0.0, please
-# adjust and run ./set_version.sh instead.
-version = "0.0.0"
-authors = ["Paul Makles <paulmakles@gmail.com>"]
-edition = "2018"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[dependencies]
-# Utility
-lru = "0.7.0"
-url = "2.2.2"
-log = "0.4.11"
-dotenv = "0.15.0"
-dashmap = "5.2.0"
-linkify = "0.6.0"
-once_cell = "1.4.1"
-env_logger = "0.7.1"
-lazy_static = "1.4.0"
-ctrlc = { version = "3.0", features = ["termination"] }
-
-# Lang. Utilities
-regex = "1"
-num_enum = "0.5.1"
-impl_ops = "0.1.1"
-bitfield = "0.13.2"
-
-# ID / key generation
-ulid = "0.4.1"
-nanoid = "0.4.0"
-
-# serde
-serde_json = "1.0.57"
-serde = { version = "1.0.115", features = ["derive"] }
-validator = { version = "0.14", features = ["derive"] }
-
-# async
-futures = "0.3.8"
-chrono = "0.4.15"
-async-channel = "1.6.1"
-reqwest = { version = "0.11.4", features = ["json"] }
-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"] }
-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" }
-
-# 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" ] }
-
-# quark
-revolt-quark = { git = "https://github.com/revoltchat/quark", rev = "076755e513aa6b1e955cf917f60aad9e62a73883" }
-# revolt-quark = { path = "../quark" }
+[workspace]
+members = ["crates/*"]

Dockerfile

@@ -3,20 +3,10 @@ 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
+# Install build requirements
 RUN apt-get update && apt-get install -y libssl-dev pkg-config
 
+# Build all crates
 COPY Cargo.toml Cargo.lock ./
-COPY assets ./assets
-COPY src ./src
-RUN cargo install --locked --path .
-
-# Bundle Stage
-FROM debian:buster-slim
-RUN apt-get update && apt-get install -y ca-certificates
-COPY --from=builder /usr/local/cargo/bin/revolt ./
-EXPOSE 8000
-ENV ROCKET_ADDRESS 0.0.0.0
-ENV ROCKET_PORT 8000
-CMD ["./revolt"]
+COPY crates ./crates
+RUN cargo build --locked --release

LICENSE

@@ -1,7 +1,7 @@
                     GNU AFFERO GENERAL PUBLIC LICENSE
                        Version 3, 19 November 2007
 
-Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
  Everyone is permitted to copy and distribute verbatim copies
  of this license document, but changing it is not allowed.
 
@@ -629,7 +629,7 @@ 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
+    Revolt Project
     Copyright (C) 2022 Pawel Makles
 
     This program is free software: you can redistribute it and/or modify
@@ -643,7 +643,7 @@ the "copyright" line and a pointer to where the full notice is found.
     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/>.
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 Also add information on how to contact you by electronic and paper mail.
 
@@ -658,4 +658,4 @@ 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/>.
+<http://www.gnu.org/licenses/>.

README.md

@@ -1,21 +1,17 @@
-# Delta
+# Revolt Backend
 
-## Description
+This is a monorepo for the Revolt backend.
 
-Delta is the API server for the Revolt platform.
+| 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 |-->
 
-**Features:**
-
-- Robust and efficient API routes for running a chat platform.
-- Distributed notification system, allowing any node to be seamlessly connected.
-- Simple deployment, based mostly on pure Rust code and libraries.
-- Hooks up to a MongoDB deployment, provide URI and no extra work needed.
-
-## Stack
-
-- [Rocket](https://rocket.rs/) (REST)
-- [Async Tungstenite](https://github.com/sdroege/async-tungstenite) (WebSockets)
-- [MongoDB](https://mongodb.com/)
+Note: `january`, `autumn`, and `vortex` are yet to be moved into this monorepo.
 
 ## Resources
 
@@ -25,16 +21,6 @@ Delta is the API server for the Revolt platform.
 - [Revolt Testers Server](https://app.revolt.chat/invite/Testers)
 - [Contribution Guide](https://developers.revolt.chat/contributing)
 
-## CLI Commands
-
-| Command            | Description                                                                               |
-| ------------------ | ----------------------------------------------------------------------------------------- |
-| `./publish.sh`     | Publish a Docker Image.                                                                   |
-| `./set_version.sh` | Update the version. **Not intended for PR use.**                                          |
-| `cargo build`      | Build/compile Delta.                                                                      |
-| `cargo run`        | Run Delta.                                                                                |
-| `cargo fmt`        | Format Delta. Not intended for PR use to avoid accidentally formatting unformatted files. |
-
 ## Contributing
 
 The contribution guide is located at [developers.revolt.chat/contributing](https://developers.revolt.chat/contributing).
@@ -42,4 +28,4 @@ Please note that a pull request should only take care of one issue so that we ca
 
 ## License
 
-Delta is licensed under the [GNU Affero General Public License v3.0](https://github.com/revoltchat/delta/blob/master/LICENSE).
+The Revolt backend is generally licensed under the [GNU Affero General Public License v3.0](https://github.com/revoltchat/backend/blob/master/LICENSE). Please check individual crates for further license information.

build.sh

@@ -0,0 +1,7 @@
+#!/bin/bash
+# Build base image
+docker build -t revolt.chat/base:latest -f Dockerfile .
+
+# Build crates
+docker build -t revolt.chat/delta:latest -f crates/delta/Dockerfile .
+docker build -t revolt.chat/bonfire:latest -f crates/bonfire/Dockerfile .

crates/bonfire/.github/FUNDING.yml

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

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

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

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

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

@@ -0,0 +1,72 @@
+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/.gitignore

@@ -0,0 +1 @@
+/target

crates/bonfire/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "revolt-bonfire"
+version = "1.0.6-patch.2"
+license = "AGPL-3.0-or-later"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+# util
+log = "*"
+once_cell = "1.9.0"
+
+# parsing
+querystring = "1.1.0"
+
+# quark
+revolt-quark = { path = "../quark" }
+
+# serde
+serde_json = "1.0.79"
+rmp-serde = "1.0.0"
+serde = "1.0.136"
+
+# async
+futures = "0.3.21"
+async-tungstenite = { version = "0.17.0", features = ["async-std-runtime"] }
+async-std = { version = "1.8.0", features = ["tokio1", "tokio02", "attributes"] }

crates/bonfire/Dockerfile

@@ -0,0 +1,10 @@
+# Build Stage
+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/revolt-bonfire ./
+EXPOSE 9000
+CMD ["./revolt-bonfire"]

crates/bonfire/LICENSE

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

crates/bonfire/src/config.rs

@@ -0,0 +1,150 @@
+use async_tungstenite::tungstenite::{handshake, Message};
+use futures::channel::oneshot::Sender;
+use revolt_quark::{Error, Result};
+use serde::{Deserialize, Serialize};
+
+/// Enumeration of supported protocol formats
+#[derive(Debug)]
+pub enum ProtocolFormat {
+    Json,
+    Msgpack,
+}
+
+/// User-provided protocol configuration
+#[derive(Debug)]
+pub struct ProtocolConfiguration {
+    protocol_version: i32,
+    format: ProtocolFormat,
+    session_token: Option<String>,
+}
+
+impl ProtocolConfiguration {
+    /// Create a new protocol configuration object from provided data
+    pub fn from(
+        protocol_version: i32,
+        format: ProtocolFormat,
+        session_token: Option<String>,
+    ) -> Self {
+        Self {
+            protocol_version,
+            format,
+            session_token,
+        }
+    }
+
+    /// Decode some WebSocket message into a T: Deserialize using the client's specified protocol format
+    pub fn decode<'a, T: Deserialize<'a>>(&self, msg: &'a Message) -> Result<T> {
+        match self.format {
+            ProtocolFormat::Json => {
+                if let Message::Text(text) = msg {
+                    serde_json::from_str(text).map_err(|_| Error::InternalError)
+                } else {
+                    Err(Error::InternalError)
+                }
+            }
+            ProtocolFormat::Msgpack => {
+                if let Message::Binary(buf) = msg {
+                    rmp_serde::from_slice(buf).map_err(|_| Error::InternalError)
+                } else {
+                    Err(Error::InternalError)
+                }
+            }
+        }
+    }
+
+    /// Encode T: Serialize into a WebSocket message using the client's specified protocol format
+    pub fn encode<T: Serialize>(&self, data: &T) -> Message {
+        match self.format {
+            ProtocolFormat::Json => {
+                Message::Text(serde_json::to_string(data).expect("Failed to serialise (as json)."))
+            }
+            ProtocolFormat::Msgpack => Message::Binary(
+                rmp_serde::to_vec_named(data).expect("Failed to serialise (as msgpack)."),
+            ),
+        }
+    }
+
+    /// Set the current session token
+    pub fn set_session_token(&mut self, token: String) {
+        self.session_token.replace(token);
+    }
+
+    /// Get the current session token
+    pub fn get_session_token(&self) -> &Option<String> {
+        &self.session_token
+    }
+
+    /// Get the protocol version specified
+    pub fn get_protocol_version(&self) -> i32 {
+        self.protocol_version
+    }
+
+    /// Get the protocol format specified
+    pub fn get_protocol_format(&self) -> &ProtocolFormat {
+        &self.format
+    }
+}
+
+/// Object holding one side of a channel for receiving the parsed information
+pub struct WebsocketHandshakeCallback {
+    sender: Sender<ProtocolConfiguration>,
+}
+
+impl WebsocketHandshakeCallback {
+    /// Create a callback using a given sender
+    pub fn from(sender: Sender<ProtocolConfiguration>) -> Self {
+        Self { sender }
+    }
+}
+
+impl handshake::server::Callback for WebsocketHandshakeCallback {
+    /// Handle request to create a new WebSocket connection
+    fn on_request(
+        self,
+        request: &handshake::server::Request,
+        response: handshake::server::Response,
+    ) -> Result<handshake::server::Response, handshake::server::ErrorResponse> {
+        // Take and parse query parameters from the URI.
+        let query = request.uri().query().unwrap_or_default();
+        let params = querystring::querify(query);
+
+        // Set default values for the protocol.
+        let mut protocol_version = 1;
+        let mut format = ProtocolFormat::Json;
+        let mut session_token = None;
+
+        // Parse and map parameters from key-value to known variables.
+        for (key, value) in params {
+            match key {
+                "version" => {
+                    if let Ok(version) = value.parse() {
+                        protocol_version = version;
+                    }
+                }
+                "format" => match value {
+                    "json" => format = ProtocolFormat::Json,
+                    "msgpack" => format = ProtocolFormat::Msgpack,
+                    _ => {}
+                },
+                "token" => session_token = Some(value.into()),
+                _ => {}
+            }
+        }
+
+        // Send configuration information back from this callback.
+        // We have to use a channel as this function does not borrow mutably.
+        if self
+            .sender
+            .send(ProtocolConfiguration {
+                protocol_version,
+                format,
+                session_token,
+            })
+            .is_ok()
+        {
+            Ok(response)
+        } else {
+            Err(handshake::server::ErrorResponse::new(None))
+        }
+    }
+}

crates/bonfire/src/database.rs

@@ -0,0 +1,19 @@
+use once_cell::sync::OnceCell;
+use revolt_quark::{Database, DatabaseInfo};
+
+static DBCONN: OnceCell<Database> = OnceCell::new();
+
+/// Connect Bonfire to the database.
+pub async fn connect() {
+    let database = DatabaseInfo::Auto
+        .connect()
+        .await
+        .expect("Failed to connect to the database.");
+
+    DBCONN.set(database).expect("Setting `Database`");
+}
+
+/// Get a reference to the current database.
+pub fn get_db() -> &'static Database {
+    DBCONN.get().expect("Valid `Database`")
+}

crates/bonfire/src/main.rs

@@ -0,0 +1,34 @@
+use std::env;
+
+use async_std::net::TcpListener;
+use revolt_quark::presence::presence_clear_region;
+
+#[macro_use]
+extern crate log;
+
+pub mod config;
+
+mod database;
+mod websocket;
+
+#[async_std::main]
+async fn main() {
+    // Configure requirements for Bonfire.
+    revolt_quark::configure!();
+    database::connect().await;
+
+    // Clean up the current region information.
+    presence_clear_region(None).await;
+
+    // Setup a TCP listener to accept WebSocket connections on.
+    // By default, we bind to port 9000 on all interfaces.
+    let bind = env::var("HOST").unwrap_or_else(|_| "0.0.0.0:9000".into());
+    info!("Listening on host {bind}");
+    let try_socket = TcpListener::bind(bind).await;
+    let listener = try_socket.expect("Failed to bind");
+
+    // Start accepting new connections and spawn a client for each connection.
+    while let Ok((stream, addr)) = listener.accept().await {
+        websocket::spawn_client(database::get_db(), stream, addr);
+    }
+}

crates/bonfire/src/websocket.rs

@@ -0,0 +1,253 @@
+use std::net::SocketAddr;
+
+use futures::{channel::oneshot, pin_mut, select, FutureExt, SinkExt, StreamExt, TryStreamExt};
+use revolt_quark::{
+    events::{
+        client::EventV1,
+        server::ClientMessage,
+        state::{State, SubscriptionStateChange},
+    },
+    models::{user::UserHint, User},
+    presence::{presence_create_session, presence_delete_session},
+    redis_kiss, Database,
+};
+
+use async_std::{net::TcpStream, sync::Mutex, task};
+
+use crate::config::WebsocketHandshakeCallback;
+
+/// Spawn a new WebSocket client worker given access to the database,
+/// the relevant TCP stream and the remote address of the client.
+pub fn spawn_client(db: &'static Database, stream: TcpStream, addr: SocketAddr) {
+    // Spawn a new Async task to work on.
+    task::spawn(async move {
+        info!("User connected from {addr:?}");
+
+        // Upgrade the TCP connection to a WebSocket connection.
+        // In this process, we also parse any additional parameters given.
+        // e.g. wss://example.com?format=json&version=1
+        let (sender, receiver) = oneshot::channel();
+        if let Ok(ws) = async_tungstenite::accept_hdr_async_with_config(
+            stream,
+            WebsocketHandshakeCallback::from(sender),
+            None,
+        )
+        .await
+        {
+            // Verify we've received a valid config, otherwise we should just drop the connection.
+            if let Ok(mut config) = receiver.await {
+                info!(
+                    "User {addr:?} provided protocol configuration (version = {}, format = {:?})",
+                    config.get_protocol_version(),
+                    config.get_protocol_format()
+                );
+
+                // Split the socket for simultaneously read and write.
+                let (write, mut read) = ws.split();
+                let write = Mutex::new(write);
+
+                // If the user has not provided authentication, request information.
+                if config.get_session_token().is_none() {
+                    'outer: while let Ok(message) = read.try_next().await {
+                        if let Ok(ClientMessage::Authenticate { token }) =
+                            config.decode(message.as_ref().unwrap())
+                        {
+                            config.set_session_token(token);
+                            break 'outer;
+                        }
+                    }
+                }
+
+                // Try to authenticate the user.
+                if let Some(token) = config.get_session_token().as_ref() {
+                    match User::from_token(db, token, UserHint::Any).await {
+                        Ok(user) => {
+                            info!("User {addr:?} authenticated as @{}", user.username);
+
+                            // Create local state.
+                            let mut state = State::from(user);
+                            let user_id = state.cache.user_id.clone();
+
+                            // Create presence session.
+                            let (first_session, session_id) =
+                                presence_create_session(&user_id, 0).await;
+
+                            // Notify socket we have authenticated.
+                            write
+                                .lock()
+                                .await
+                                .send(config.encode(&EventV1::Authenticated))
+                                .await
+                                .ok();
+
+                            // Download required data to local cache and send Ready payload.
+                            if let Ok(ready_payload) = state.generate_ready_payload(db).await {
+                                write
+                                    .lock()
+                                    .await
+                                    .send(config.encode(&ready_payload))
+                                    .await
+                                    .ok();
+
+                                // If this was the first session, notify other users that we just went online.
+                                if first_session {
+                                    state.broadcast_presence_change(true).await;
+                                }
+
+                                // Create a PubSub connection to poll on.
+                                let listener = async {
+                                    if let Ok(mut conn) = redis_kiss::open_pubsub_connection().await
+                                    {
+                                        loop {
+                                            // Check for state changes for subscriptions.
+                                            match state.apply_state() {
+                                                SubscriptionStateChange::Reset => {
+                                                    for id in state.iter_subscriptions() {
+                                                        conn.subscribe(id).await.unwrap();
+                                                    }
+
+                                                    #[cfg(debug_assertions)]
+                                                    info!("{addr:?} has reset their subscriptions");
+                                                }
+                                                SubscriptionStateChange::Change { add, remove } => {
+                                                    for id in remove {
+                                                        #[cfg(debug_assertions)]
+                                                        info!("{addr:?} unsubscribing from {id}");
+
+                                                        conn.unsubscribe(id).await.unwrap();
+                                                    }
+
+                                                    for id in add {
+                                                        #[cfg(debug_assertions)]
+                                                        info!("{addr:?} subscribing to {id}");
+
+                                                        conn.subscribe(id).await.unwrap();
+                                                    }
+                                                }
+                                                SubscriptionStateChange::None => {}
+                                            }
+
+                                            // * Debug logging of current subscriptions.
+                                            /*#[cfg(debug_assertions)]
+                                            info!(
+                                                "User {addr:?} is subscribed to {:?}",
+                                                state
+                                                    .iter_subscriptions()
+                                                    .collect::<Vec<&String>>()
+                                            );*/
+
+                                            // Handle incoming events.
+                                            match conn.on_message().next().await.map(|item| {
+                                                (
+                                                    item.get_channel_name().to_string(),
+                                                    redis_kiss::decode_payload::<EventV1>(&item),
+                                                )
+                                            }) {
+                                                Some((channel, item)) => {
+                                                    if let Ok(mut event) = item {
+                                                        if state
+                                                            .handle_incoming_event_v1(
+                                                                db, &mut event,
+                                                            )
+                                                            .await
+                                                            && write.lock().await
+                                                                .send(config.encode(&event))
+                                                                .await
+                                                                .is_err()
+                                                        {
+                                                            break;
+                                                        }
+                                                    } else {
+                                                        warn!("Failed to deserialise an event for {channel}!");
+                                                    }
+                                                }
+                                                // No more data, assume we disconnected or otherwise
+                                                // something bad occurred, so disconnect user.
+                                                None => break,
+                                            }
+                                        }
+                                    }
+                                }
+                                .fuse();
+
+                                // Read from WebSocket stream.
+                                let worker =
+                                    async {
+                                        while let Ok(Some(msg)) = read.try_next().await {
+                                            if let Ok(payload) = config.decode(&msg) {
+                                                match payload {
+                                                    ClientMessage::BeginTyping { channel } => {
+                                                        EventV1::ChannelStartTyping {
+                                                            id: channel.clone(),
+                                                            user: user_id.clone(),
+                                                        }
+                                                        .p(channel.clone())
+                                                        .await;
+                                                    }
+                                                    ClientMessage::EndTyping { channel } => {
+                                                        EventV1::ChannelStopTyping {
+                                                            id: channel.clone(),
+                                                            user: user_id.clone(),
+                                                        }
+                                                        .p(channel.clone())
+                                                        .await;
+                                                    }
+                                                    ClientMessage::Ping { data, responded } => {
+                                                        if responded.is_none() {
+                                                            write
+                                                                .lock()
+                                                                .await
+                                                                .send(config.encode(
+                                                                    &EventV1::Pong { data },
+                                                                ))
+                                                                .await
+                                                                .ok();
+                                                        }
+                                                    }
+                                                    _ => {}
+                                                }
+                                            }
+                                        }
+                                    }
+                                    .fuse();
+
+                                // Pin both tasks.
+                                pin_mut!(listener, worker);
+
+                                // Wait for either disconnect or for listener to die.
+                                select!(
+                                    () = listener => {},
+                                    () = worker => {}
+                                );
+
+                                // * Combine the streams back once we are ready to disconnect.
+                                /* ws = read.reunite(write).unwrap(); */
+                            }
+
+                            // Clean up presence session.
+                            let last_session = presence_delete_session(&user_id, session_id).await;
+
+                            // If this was the last session, notify other users that we just went offline.
+                            if last_session {
+                                state.broadcast_presence_change(false).await;
+                            }
+                        }
+                        Err(err) => {
+                            write.lock().await.send(config.encode(&err)).await.ok();
+                        }
+                    }
+                }
+            }
+
+            // * Disconnect the WebSocket if it isn't already.
+            /*ws.close(Some(CloseFrame {
+                code: CloseCode::Normal,
+                reason: std::borrow::Cow::from(""),
+            }))
+            .await
+            .unwrap();*/
+        }
+
+        info!("User disconnected from {addr:?}");
+    });
+}

crates/delta/Cargo.toml

@@ -0,0 +1,63 @@
+[package]
+name = "revolt-delta"
+version = "0.5.3-7"
+license = "AGPL-3.0-or-later"
+authors = ["Paul Makles <paulmakles@gmail.com>"]
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+# Utility
+lru = "0.7.0"
+url = "2.2.2"
+log = "0.4.11"
+dotenv = "0.15.0"
+dashmap = "5.2.0"
+linkify = "0.6.0"
+once_cell = "1.4.1"
+env_logger = "0.7.1"
+lazy_static = "1.4.0"
+
+# Lang. Utilities
+regex = "1"
+num_enum = "0.5.1"
+impl_ops = "0.1.1"
+bitfield = "0.13.2"
+
+# ID / key generation
+ulid = "0.4.1"
+nanoid = "0.4.0"
+
+# serde
+serde_json = "1.0.57"
+serde = { version = "1.0.115", features = ["derive"] }
+validator = { version = "0.14", features = ["derive"] }
+
+# async
+futures = "0.3.8"
+chrono = "0.4.15"
+async-channel = "1.6.1"
+reqwest = { version = "0.11.4", features = ["json"] }
+async-std = { version = "1.8.0", features = ["tokio1", "tokio02", "attributes"] }
+
+# internal util
+lettre = "0.10.0-alpha.4"
+
+# redis
+redis = { version = "0.21.2", features = ["async-std-comp"] }
+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.2", default-features = false, features = ["json"] }
+rocket_empty = { git = "https://github.com/insertish/rocket_empty", branch = "master" }
+rocket_rauth = { git = "https://github.com/insertish/rauth", rev = "ab7cc5a9739f1147375d3a559250f4be2a051565" }
+
+# spec generation
+schemars = "0.8.8"
+# rocket_okapi = "0.8.0-rc.1"
+rocket_okapi = { git = "https://github.com/insertish/okapi", rev = "a1048d0c8cd771e424ec97d33d825c32e06aa120", features = [ "swagger" ] }
+
+# quark
+revolt-quark = { path = "../quark" }

crates/delta/Dockerfile

@@ -0,0 +1,13 @@
+# Build Stage
+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-delta ./
+
+EXPOSE 8000
+ENV ROCKET_ADDRESS 0.0.0.0
+ENV ROCKET_PORT 8000
+CMD ["./revolt-delta"]

crates/delta/LICENSE

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

crates/delta/src/main.rs

@@ -0,0 +1,51 @@
+#[macro_use]
+extern crate rocket;
+#[macro_use]
+extern crate rocket_okapi;
+#[macro_use]
+extern crate serde_json;
+#[macro_use]
+extern crate lazy_static;
+
+pub mod routes;
+pub mod util;
+
+use revolt_quark::rauth::RAuth;
+use revolt_quark::DatabaseInfo;
+
+#[launch]
+async fn rocket() -> _ {
+    // Configure logging and environment
+    revolt_quark::configure!();
+
+    // Ensure environment variables are present
+    revolt_quark::variables::delta::preflight_checks();
+
+    // Setup database
+    let db = DatabaseInfo::Auto.connect().await.unwrap();
+    db.migrate_database().await.unwrap();
+
+    // Setup rAuth
+    let rauth = RAuth {
+        database: db.clone().into(),
+        config: revolt_quark::util::rauth::config(),
+    };
+
+    // Launch background task workers.
+    async_std::task::spawn(revolt_quark::tasks::start_workers(db.clone()));
+
+    // Configure CORS
+    let cors = revolt_quark::web::cors::new();
+
+    // Configure Rocket
+    let rocket = rocket::build();
+    routes::mount(rocket)
+        .mount("/", revolt_quark::web::cors::catch_all_options_routes())
+        .mount("/", revolt_quark::web::ratelimiter::routes())
+        .mount("/swagger/", revolt_quark::web::swagger::routes())
+        .manage(rauth)
+        .manage(db)
+        .manage(cors.clone())
+        .attach(revolt_quark::web::ratelimiter::RatelimitFairing)
+        .attach(cors)
+}

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

@@ -5,7 +5,9 @@ use revolt_quark::{
         message::{Masquerade, Reply, SendableEmbed},
         Message, User,
     },
-    perms, Db, Error, Permission, Ref, Result,
+    perms,
+    web::idempotency::IdempotencyKey,
+    Db, Error, Permission, Ref, Result,
 };
 
 use regex::Regex;
@@ -14,8 +16,6 @@ use serde::{Deserialize, Serialize};
 use ulid::Ulid;
 use validator::Validate;
 
-use crate::util::idempotency::IdempotencyKey;
-
 #[derive(Validate, Serialize, Deserialize, JsonSchema)]
 pub struct DataMessageSend {
     /// Unique token to prevent duplicate message sending
@@ -134,7 +134,19 @@ pub async fn message_send(
             .replace(replies.into_iter().collect::<Vec<String>>());
     }
 
-    // 4. Add attachments to message.
+    // 4. 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);
+    }
+
+    // 5. Add attachments to message.
     let mut attachments = vec![];
     if let Some(ids) = &data.attachments {
         if !ids.is_empty() {
@@ -160,18 +172,6 @@ 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
     message.content = data.content;
 

crates/delta/src/routes/mod.rs

@@ -25,8 +25,9 @@ pub fn mount(mut rocket: Rocket<Build>) -> Rocket<Build> {
         "/channels" => channels::routes(),
         "/servers" => servers::routes(),
         "/invites" => invites::routes(),
-        "/auth/account" => rauth::web::account::routes(),
-        "/auth/session" => rauth::web::session::routes(),
+        "/auth/account" => rocket_rauth::routes::account::routes(),
+        "/auth/session" => rocket_rauth::routes::session::routes(),
+        "/auth/mfa" => rocket_rauth::routes::mfa::routes(),
         "/onboard" => onboard::routes(),
         "/push" => push::routes(),
         "/sync" => sync::routes(),
@@ -100,7 +101,8 @@ fn custom_openapi_spec() -> OpenApi {
             "tags": [
               "Account",
               "Session",
-              "Onboarding"
+              "Onboarding",
+              "MFA"
             ]
           },
           {
@@ -117,7 +119,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 +132,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 +244,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,6 @@
 use crate::util::regex::RE_USERNAME;
-use revolt_quark::{models::User, Database, EmptyResponse, Error, Result};
+use revolt_quark::{models::User, rauth::models::Session, Database, EmptyResponse, Error, Result};
 
-use rauth::entities::Session;
 use rocket::{serde::json::Json, State};
 use serde::{Deserialize, Serialize};
 use validator::Validate;

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

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

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::{
+    rauth::{
+        models::{Session, WebPushSubscription},
+        RAuth,
+    },
+    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>,
+    rauth: &State<RAuth>,
     mut session: Session,
     data: Json<WebPushSubscription>,
 ) -> Result<EmptyResponse> {
     session.subscription = Some(data.into_inner());
     session
-        .save(&auth.db, None)
+        .save(&rauth)
         .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::{
+    rauth::{models::Session, RAuth},
+    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(rauth: &State<RAuth>, mut session: Session) -> Result<EmptyResponse> {
     session.subscription = None;
     session
-        .save(&auth.db, None)
+        .save(&rauth)
         .await
         .map(|_| EmptyResponse)
         .map_err(|_| Error::DatabaseError {

crates/delta/src/routes/root.rs

@@ -76,7 +76,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,

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

@@ -0,0 +1,163 @@
+use std::collections::HashSet;
+
+use revolt_quark::{
+    models::{
+        server_member::{FieldsMember, PartialMember},
+        File, Member, User,
+    },
+    perms, Db, Error, Permission, Ref, Result,
+};
+
+use rocket::serde::json::Json;
+use serde::{Deserialize, Serialize};
+use validator::Validate;
+
+/// # Member Data
+#[derive(Validate, Serialize, Deserialize, JsonSchema)]
+pub struct DataMemberEdit {
+    /// Member nickname
+    #[validate(length(min = 1, max = 32))]
+    nickname: Option<String>,
+    /// Attachment Id to set for avatar
+    avatar: Option<String>,
+    /// Array of role ids
+    roles: Option<Vec<String>>,
+    /// Fields to remove from channel object
+    #[validate(length(min = 1))]
+    remove: Option<Vec<FieldsMember>>,
+}
+
+/// # Edit Member
+///
+/// Edit a member by their id.
+#[openapi(tag = "Server Members")]
+#[patch("/<server>/members/<target>", data = "<data>")]
+pub async fn req(
+    db: &Db,
+    user: User,
+    server: Ref,
+    target: Ref,
+    data: Json<DataMemberEdit>,
+) -> Result<Json<Member>> {
+    let data = data.into_inner();
+    data.validate()
+        .map_err(|error| Error::FailedValidation { error })?;
+
+    // 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);
+    }
+
+    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 fallback = vec![];
+        let current_roles = member
+            .roles
+            .as_ref()
+            .unwrap_or(&fallback)
+            .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,
+        remove,
+    } = data;
+
+    let mut partial = PartialMember {
+        nickname,
+        roles,
+        ..Default::default()
+    };
+
+    // 1. Remove fields from object
+    if let Some(fields) = &remove {
+        if fields.contains(&FieldsMember::Avatar) {
+            if let Some(avatar) = &member.avatar {
+                db.mark_attachment_as_deleted(&avatar.id).await?;
+            }
+        }
+    }
+
+    // 2. Apply new avatar
+    if let Some(avatar) = avatar {
+        partial.avatar = Some(File::use_avatar(db, &avatar, &user.id).await?);
+    }
+
+    member
+        .update(db, partial, remove.unwrap_or_default())
+        .await?;
+
+    Ok(Json(member))
+}

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

@@ -0,0 +1,25 @@
+use revolt_quark::models::User;
+use revolt_quark::{Database, Error, Ref, Result};
+
+use rocket::serde::json::Json;
+use rocket::State;
+
+/// # Accept Friend Request
+///
+/// Accept another user's friend request.
+#[openapi(tag = "Relationships")]
+#[put("/<target>/friend")]
+pub async fn req(db: &State<Database>, user: User, target: Ref) -> Result<Json<User>> {
+    let mut target = if let Ok(user) = db.fetch_user_by_username(&target.id).await {
+        user
+    } else {
+        target.as_user(db).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/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::{models::User, rauth::models::Account, Database, Error, Result};
 use rocket::{serde::json::Json, State};
 use serde::{Deserialize, Serialize};
 use validator::Validate;