feat: initialise Discord bridge crate

.config/nextest.toml

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

.env.example

@@ -1,7 +1,5 @@
 # MongoDB URI
 MONGODB=mongodb://localhost
-AUTUMN_MONGO_URI=mongodb://database
-REDIS_URI=redis://localhost/
 
 # URL to where the Revolt app is publicly accessible
 REVOLT_APP_URL=http://local.revolt.chat:5000
@@ -61,9 +59,6 @@ REVOLT_UNSAFE_NO_EMAIL=1
 ## Application Settings
 ##
 
-# Whether to enable staging only features
-REVOLT_IS_STAGING=1
-
 # Whether to only allow users to sign up if they have an invite code
 REVOLT_INVITE_ONLY=0
 
@@ -82,26 +77,3 @@ REVOLT_VAPID_PUBLIC_KEY=BGcvgR-i2z4IQ5Mw841vJvkLjt8wY-FjmWrw83jOLCY52qcGZS0OF7nf
 ##
 
 # VOSO_MANAGE_TOKEN=CHANGEME
-
-
-##
-## Autumn configuration
-##
-
-# S3 Region
-AUTUMN_S3_REGION=minio
-
-# S3 Endpoint
-AUTUMN_S3_ENDPOINT=http://minio:9000
-
-# MinIO Root User
-MINIO_ROOT_USER=minioautumn
-
-# MinIO Root Password
-MINIO_ROOT_PASSWORD=minioautumn
-
-# AWS Access Key ID
-AWS_ACCESS_KEY_ID=minioautumn
-
-# AWS Secret Key
-AWS_SECRET_ACCESS_KEY=minioautumn

.github/workflows/docker.yaml

@@ -3,7 +3,7 @@ name: Docker Test & Publish
 on:
   push:
     branches:
-      - "main"
+      - "master"
     tags:
       - "*"
     paths-ignore:
@@ -15,7 +15,7 @@ on:
       - "README"
   pull_request:
     branches:
-      - "main"
+      - "master"
     paths:
       - "Dockerfile"
   workflow_dispatch:

.github/workflows/rust.yaml

@@ -2,8 +2,9 @@ name: Rust build, test, and generate specification
 
 on:
   push:
+    branches: [master]
   pull_request:
-    branches: [main]
+    branches: [master]
 
 env:
   CARGO_TERM_COLOR: always
@@ -20,53 +21,40 @@ jobs:
           toolchain: stable
           override: true
           components: rustfmt, clippy
-      - name: Install cargo-nextest
-        uses: baptiste0928/cargo-install@v1
-        with:
-          crate: cargo-nextest
-          locked: true
 
       - name: Run cargo build
         uses: actions-rs/cargo@v1
         with:
           command: build
 
-      - name: Run services in background
-        run: |
-          docker-compose -f docker-compose.db.yml up -d
+      - 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 cargo test
-        env:
-          TEST_DB: REFERENCE
+      - name: Run services in background
+        if: github.event_name != 'pull_request'
         run: |
-          cargo nextest run
-
-      - name: Run cargo test (with MongoDB)
-        env:
-          TEST_DB: MONGODB
-          MONGODB: mongodb://localhost
-        run: |
-          cargo nextest run
+          docker-compose -f docker-compose.db.yml up -d
 
       - name: Start API in background
-        if: github.event_name != 'pull_request' && github.ref_name == 'main'
-        env:
-          TEST_DB: REFERENCE
+        if: github.event_name != 'pull_request'
         run: |
-          cargo build --bin revolt-delta && (cargo run --bin revolt-delta &)
+          cargo run --bin revolt-delta &
 
       - name: Wait for API to go up
-        if: github.event_name != 'pull_request' && github.ref_name == 'main'
+        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' && github.ref_name == 'main'
+        if: github.event_name != 'pull_request'
         uses: actions/checkout@v3
         with:
           repository: revoltchat/api
@@ -74,11 +62,11 @@ jobs:
           token: ${{ secrets.PAT }}
 
       - name: Download OpenAPI specification
-        if: github.event_name != 'pull_request' && github.ref_name == 'main'
+        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' && github.ref_name == 'main'
+        if: github.event_name != 'pull_request'
         uses: EndBug/add-and-commit@v4
         with:
           cwd: "api"

.github/workflows/triage_pr.yml

@@ -15,7 +15,7 @@ jobs:
           gh api graphql -f query='
             query {
               organization(login: "revoltchat"){
-                projectV2(number: 5) {
+                projectV2(number: 3) {
                   id
                   fields(first:20) {
                     nodes {
@@ -35,7 +35,7 @@ jobs:
 
           echo 'PROJECT_ID='$(jq '.data.organization.projectV2.id' project_data.json) >> $GITHUB_ENV
           echo 'STATUS_FIELD_ID='$(jq '.data.organization.projectV2.fields.nodes[] | select(.name== "Status") | .id' project_data.json) >> $GITHUB_ENV
-          echo 'INCOMING_OPTION_ID='$(jq '.data.organization.projectV2.fields.nodes[] | select(.name== "Status") | .options[] | select(.name=="🆕 Untriaged") |.id' project_data.json) >> $GITHUB_ENV
+          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:

.gitignore

@@ -1,9 +1,6 @@
 Rocket.toml
-Revolt.toml
-
 target
 .data
 .env
 
 .vercel
-.DS_Store

.vscode/settings.json

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

Cargo.toml

@@ -1,10 +1,7 @@
 [workspace]
-resolver = "2"
-members = ["crates/delta", "crates/bonfire", "crates/core/*"]
+members = ["crates/*", "crates/bridges/*"]
+exclude = ["crates/bridges"]
 
 [patch.crates-io]
 # mobc-redis = { git = "https://github.com/insertish/mobc", rev = "8b880bb59f2ba80b4c7bc40c649c113d8857a186" }
-redis22 = { package = "redis", version = "0.22.3", git = "https://github.com/revoltchat/redis-rs", rev = "1a41faf356fd21aebba71cea7eb7eb2653e5f0ef" }
-redis23 = { package = "redis", version = "0.23.1", git = "https://github.com/revoltchat/redis-rs", rev = "f8ca28ab85da59d2ccde526b4d2fb390eff5a5f9" }
-# authifier = { package = "authifier", version = "1.0.8", path = "../authifier/crates/authifier" }
-# rocket_authifier = { package = "rocket_authifier", version = "1.0.8", path = "../authifier/crates/rocket_authifier" }
+redis = { git = "https://github.com/insertish/redis-rs", rev = "6575a6b1c09eb8c9cc7f0082d95fe6b8f903c4d7" }

Dockerfile

@@ -1,5 +1,5 @@
 # Build Stage
-FROM --platform="${BUILDPLATFORM}" rust:1.70.0-slim
+FROM --platform="${BUILDPLATFORM}" rustlang/rust:nightly-slim
 USER 0:0
 WORKDIR /home/rust/src
 
@@ -19,12 +19,7 @@ RUN sh /tmp/build-image-layer.sh tools
 COPY Cargo.toml Cargo.lock ./
 COPY crates/bonfire/Cargo.toml ./crates/bonfire/
 COPY crates/delta/Cargo.toml ./crates/delta/
-COPY crates/core/config/Cargo.toml ./crates/core/config/
-COPY crates/core/database/Cargo.toml ./crates/core/database/
-COPY crates/core/models/Cargo.toml ./crates/core/models/
-COPY crates/core/permissions/Cargo.toml ./crates/core/permissions/
-COPY crates/core/presence/Cargo.toml ./crates/core/presence/
-COPY crates/core/result/Cargo.toml ./crates/core/result/
+COPY crates/quark/Cargo.toml ./crates/quark/
 RUN sh /tmp/build-image-layer.sh deps
 
 # Build all apps

Dockerfile.useCurrentArch

@@ -1,28 +0,0 @@
-# Build Stage
-FROM rust:1.70.0-slim
-USER 0:0
-WORKDIR /home/rust/src
-
-# Install build requirements
-RUN apt-get update && \
-    apt-get install -y \
-    make \
-    pkg-config \
-    libssl-dev
-COPY scripts/build-image-layer.sh /tmp/
-
-# Build all dependencies
-COPY Cargo.toml Cargo.lock ./
-COPY crates/bonfire/Cargo.toml ./crates/bonfire/
-COPY crates/delta/Cargo.toml ./crates/delta/
-COPY crates/core/config/Cargo.toml ./crates/core/config/
-COPY crates/core/database/Cargo.toml ./crates/core/database/
-COPY crates/core/models/Cargo.toml ./crates/core/models/
-COPY crates/core/permissions/Cargo.toml ./crates/core/permissions/
-COPY crates/core/presence/Cargo.toml ./crates/core/presence/
-COPY crates/core/result/Cargo.toml ./crates/core/result/
-RUN sh /tmp/build-image-layer.sh deps
-
-# Build all apps
-COPY crates ./crates
-RUN sh /tmp/build-image-layer.sh apps

README.md

@@ -2,111 +2,30 @@
 
 This is a monorepo for the Revolt backend.
 
-| Crate              | Path                                               | Description                   |
-| ------------------ | -------------------------------------------------- | ----------------------------- |
-| `core/config`      | [crates/core/config](crates/core/config)           | Core: Configuration           |
-| `core/database`    | [crates/core/database](crates/core/database)       | Core: Database Implementation |
-| `core/models`      | [crates/core/models](crates/core/models)           | Core: API Models              |
-| `core/permissions` | [crates/core/permissions](crates/core/permissions) | Core: Permission Logic        |
-| `core/presence`    | [crates/core/presence](crates/core/presence)       | Core: User Presence           |
-| `core/result`      | [crates/core/result](crates/core/result)           | Core: Result and Error types  |
-| `delta`            | [crates/delta](crates/delta)                       | REST API server               |
-| `bonfire`          | [crates/bonfire](crates/bonfire)                   | WebSocket events server       |
+| 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.
 
-## Minimum Supported Rust Version
+## Resources
 
-Rust 1.70 or higher.
+### Revolt
 
-## Development Guide
+- [Revolt Project Board](https://github.com/revoltchat/revolt/discussions) (Submit feature requests here)
+- [Revolt Testers Server](https://app.revolt.chat/invite/Testers)
+- [Contribution Guide](https://developers.revolt.chat/contributing)
 
-Before getting started, you'll want to install:
+## Contributing
 
-- Rust toolchain (rustup recommended)
-- Docker
-- Git
-- mold (optional, faster compilation)
-
-> A **default.nix** is available for Nix users!
-> Just run `nix-shell` and continue.
-
-Now you can clone and build the project:
-
-```bash
-git clone https://github.com/revoltchat/backend revolt-backend
-cd revolt-backend
-cargo build
-```
-
-If you want to run the API and event servers:
-
-```bash
-# create environment file (will be deprecated in future)
-cp .env.example .env
-
-# (optionally) copy the default configuration file
-cp crates/core/config/Revolt.toml Revolt.toml
-# configure as necessary...
-
-# start other necessary services
-docker compose up -d
-
-# run the API server
-cargo run --bin revolt-delta
-# run the events server
-cargo run --bin revolt-bonfire
-
-# hint:
-# mold -run <cargo build, cargo run, etc...>
-```
-
-You can start a web client by doing the following:
-
-```bash
-# if you do not have yarn yet and have a modern Node.js:
-corepack enable
-
-# clone the web client and run it:
-git clone --recursive https://github.com/revoltchat/revite
-cd revite
-yarn
-yarn build:deps
-yarn dev --port 3001
-```
-
-Then go to https://local.revolt.chat:3001
-
-## Deployment Guide
-
-### Cutting new crate releases
-
-Begin by bumping crate versions:
-
-```bash
-just patch # 0.0.X
-just minor # 0.X.0
-just major # X.0.0
-```
-
-Then commit the changes to package files.
-
-Proceed to publish all the new crates:
-
-```bash
-just publish
-```
-
-### Cutting new binary releases
-
-Tag and push a new release by running:
-
-```bash
-just release
-```
+The contribution guide is located at [developers.revolt.chat/contributing](https://developers.revolt.chat/contributing).
+Please note that a pull request should only take care of one issue so that we can review it quickly.
 
 ## License
 
-The Revolt backend is generally licensed under the [GNU Affero General Public License v3.0](https://github.com/revoltchat/backend/blob/master/LICENSE).
-
-**Individual crates may supply their own licenses!**
+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.

STYLE_GUIDE.md

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

clippy.toml

@@ -1,28 +0,0 @@
-disallowed-methods = [
-    # Shouldn't need to access these directly
-    "revolt_database::models::bots::model::Bot::remove_field",
-    "revolt_database::models::messages::model::Message::attach_sendable_embed",
-    "revolt_database::models::users::model::User::set_relationship",
-    "revolt_database::models::users::model::User::apply_relationship",
-
-    # Prefer to use Object::create()
-    "revolt_database::models::bots::ops::AbstractBots::insert_bot",
-    "revolt_database::models::channel_invites::ops::AbstractChannelInvites::insert_invite",
-    "revolt_database::models::channel_unreads::ops::AbstractChannelUnreads::acknowledge_message",
-    "revolt_database::models::channel_webhooks::ops::AbstractWebhooks::insert_webhook",
-    "revolt_database::models::channels::ops::AbstractChannels::insert_channel",
-    "revolt_database::models::emojis::ops::AbstractEmojis::insert_emoji",
-    "revolt_database::models::files::ops::AbstractAttachments::insert_attachment",
-    "revolt_database::models::messages::ops::AbstractMessages::insert_message",
-    "revolt_database::models::ratelimit_events::ops::AbstractRatelimitEvents::insert_ratelimit_event",
-    "revolt_database::models::server_bans::ops::AbstractServerBans::insert_ban",
-    "revolt_database::models::server_members::ops::AbstractServerMembers::insert_member",
-    "revolt_database::models::servers::ops::AbstractServers::insert_server",
-    "revolt_database::models::users::ops::AbstractUsers::insert_user",
-
-    # Prefer to use Object::update(&self)
-    "revolt_database::models::bots::ops::AbstractBots::update_bot",
-
-    # Prefer to use Object::delete(&self)
-    "revolt_database::models::bots::ops::AbstractBots::delete_bot",
-]

crates/bonfire/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-bonfire"
-version = "0.7.1"
+version = "0.5.19"
 license = "AGPL-3.0-or-later"
 edition = "2021"
 
@@ -9,17 +9,15 @@ edition = "2021"
 [dependencies]
 # util
 log = "*"
-sentry = "0.31.5"
-lru = "0.7.6"
-ulid = "0.5.0"
 once_cell = "1.9.0"
-redis-kiss = "0.1.4"
 
 # parsing
 querystring = "1.1.0"
 
+# quark
+revolt-quark = { path = "../quark" }
+
 # serde
-bincode = "1.3.3"
 serde_json = "1.0.79"
 rmp-serde = "1.0.0"
 serde = "1.0.136"
@@ -27,19 +25,4 @@ 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",
-] }
-
-# core
-revolt-result = { path = "../core/result" }
-revolt-models = { path = "../core/models" }
-revolt-config = { path = "../core/config" }
-revolt-database = { path = "../core/database" }
-revolt-permissions = { version = "0.7.1", path = "../core/permissions" }
-revolt-presence = { path = "../core/presence", features = ["redis-is-patched"] }
-
-# redis
-fred = { version = "8.0.1", features = ["subscriber-client"] }
+async-std = { version = "1.8.0", features = ["tokio1", "tokio02", "attributes"] }

crates/bonfire/src/config.rs

@@ -1,6 +1,6 @@
 use async_tungstenite::tungstenite::{handshake, Message};
 use futures::channel::oneshot::Sender;
-use revolt_result::{create_error, Result};
+use revolt_quark::{Error, Result};
 use serde::{Deserialize, Serialize};
 
 /// Enumeration of supported protocol formats
@@ -37,16 +37,16 @@ impl ProtocolConfiguration {
         match self.format {
             ProtocolFormat::Json => {
                 if let Message::Text(text) = msg {
-                    serde_json::from_str(text).map_err(|_| create_error!(InternalError))
+                    serde_json::from_str(text).map_err(|_| Error::InternalError)
                 } else {
-                    Err(create_error!(InternalError))
+                    Err(Error::InternalError)
                 }
             }
             ProtocolFormat::Msgpack => {
                 if let Message::Binary(buf) = msg {
-                    rmp_serde::from_slice(buf).map_err(|_| create_error!(InternalError))
+                    rmp_serde::from_slice(buf).map_err(|_| Error::InternalError)
                 } else {
-                    Err(create_error!(InternalError))
+                    Err(Error::InternalError)
                 }
             }
         }

crates/bonfire/src/database.rs

@@ -1,5 +1,5 @@
 use once_cell::sync::OnceCell;
-use revolt_database::{Database, DatabaseInfo};
+use revolt_quark::{Database, DatabaseInfo};
 
 static DBCONN: OnceCell<Database> = OnceCell::new();
 
@@ -10,9 +10,7 @@ pub async fn connect() {
         .await
         .expect("Failed to connect to the database.");
 
-    if DBCONN.set(database).is_err() {
-        panic!("couldn't set database")
-    }
+    DBCONN.set(database).expect("Setting `Database`");
 }
 
 /// Get a reference to the current database.

crates/bonfire/src/events/mod.rs

@@ -1,2 +0,0 @@
-pub mod r#impl;
-pub mod state;

crates/bonfire/src/main.rs

@@ -1,13 +1,12 @@
 use std::env;
 
 use async_std::net::TcpListener;
-use revolt_presence::clear_region;
+use revolt_quark::presence::presence_clear_region;
 
 #[macro_use]
 extern crate log;
 
 pub mod config;
-pub mod events;
 
 mod database;
 mod websocket;
@@ -15,11 +14,11 @@ mod websocket;
 #[async_std::main]
 async fn main() {
     // Configure requirements for Bonfire.
-    revolt_config::configure!();
+    revolt_quark::configure!();
     database::connect().await;
 
     // Clean up the current region information.
-    clear_region(None).await;
+    presence_clear_region(None).await;
 
     // Setup a TCP listener to accept WebSocket connections on.
     // By default, we bind to port 9000 on all interfaces.
@@ -30,10 +29,6 @@ async fn main() {
 
     // Start accepting new connections and spawn a client for each connection.
     while let Ok((stream, addr)) = listener.accept().await {
-        async_std::task::spawn(async move {
-            info!("User connected from {addr:?}");
-            websocket::client(database::get_db(), stream, addr).await;
-            info!("User disconnected from {addr:?}");
-        });
+        websocket::spawn_client(database::get_db(), stream, addr);
     }
 }

crates/bonfire/src/websocket.rs

@@ -1,278 +1,253 @@
 use std::net::SocketAddr;
 
-use async_tungstenite::WebSocketStream;
-use fred::{
-    interfaces::{ClientLike, EventInterface, PubsubInterface},
-    types::RedisConfig,
+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 futures::{
-    channel::oneshot,
-    pin_mut, select,
-    stream::{SplitSink, SplitStream},
-    FutureExt, SinkExt, StreamExt, TryStreamExt,
-};
-use redis_kiss::{PayloadType, REDIS_PAYLOAD_TYPE, REDIS_URI};
-use revolt_database::{
-    events::{client::EventV1, server::ClientMessage},
-    Database, User, UserHint,
-};
-use revolt_presence::{create_session, delete_session};
 
-use async_std::{net::TcpStream, sync::Mutex};
+use async_std::{net::TcpStream, sync::Mutex, task};
 
-use crate::config::{ProtocolConfiguration, WebsocketHandshakeCallback};
-use crate::events::state::{State, SubscriptionStateChange};
+use crate::config::WebsocketHandshakeCallback;
 
-type WsReader = SplitStream<WebSocketStream<TcpStream>>;
-type WsWriter = SplitSink<WebSocketStream<TcpStream>, async_tungstenite::tungstenite::Message>;
-
-/// Start a new WebSocket client worker given access to the database,
+/// Spawn a new WebSocket client worker given access to the database,
 /// the relevant TCP stream and the remote address of the client.
-pub async fn client(db: &'static Database, stream: TcpStream, addr: SocketAddr) {
-    // 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();
-    let Ok(ws) = async_tungstenite::accept_hdr_async_with_config(
-        stream,
-        WebsocketHandshakeCallback::from(sender),
-        None,
-    )
-    .await
-    else {
-        return;
-    };
-    // Verify we've received a valid config, otherwise we should just drop the connection.
-    let Ok(mut config) = receiver.await else {
-        return;
-    };
-    info!(
-        "User {addr:?} provided protocol configuration (version = {}, format = {:?})",
-        config.get_protocol_version(),
-        config.get_protocol_format()
-    );
+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:?}");
 
-    // Split the socket for simultaneously read and write.
-    let (mut write, mut read) = ws.split();
-
-    // If the user has not provided authentication, request information.
-    if config.get_session_token().is_none() {
-        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;
-            }
-        }
-    }
-
-    // Try to authenticate the user.
-    let Some(token) = config.get_session_token().as_ref() else {
-        return;
-    };
-    let user = match User::from_token(db, token, UserHint::Any).await {
-        Ok(user) => user,
-        Err(err) => {
-            write.send(config.encode(&err)).await.ok();
-            return;
-        }
-    };
-    info!("User {addr:?} authenticated as @{}", user.username);
-
-    // Create local state.
-    let mut state = State::from(user);
-    let user_id = state.cache.user_id.clone();
-
-    // Notify socket we have authenticated.
-    if write
-        .send(config.encode(&EventV1::Authenticated))
+        // 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
-        .is_err()
-    {
-        return;
-    }
+        {
+            // 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()
+                );
 
-    // Download required data to local cache and send Ready payload.
-    let Ok(ready_payload) = state.generate_ready_payload(db).await else {
-        return;
-    };
-    if write.send(config.encode(&ready_payload)).await.is_err() {
-        return;
-    }
+                // Split the socket for simultaneously read and write.
+                let (write, mut read) = ws.split();
+                let write = Mutex::new(write);
 
-    // Create presence session.
-    let (first_session, session_id) = create_session(&user_id, 0).await;
+                // 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;
+                        }
+                    }
+                }
 
-    // If this was the first session, notify other users that we just went online.
-    if first_session {
-        state.broadcast_presence_change(true).await;
-    }
+                // 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);
 
-    {
-        let write = Mutex::new(write);
-        // Create a PubSub connection to poll on.
-        let listener = listener(db, &mut state, addr, &config, &write).fuse();
-        // Read from WebSocket stream.
-        let worker = worker(addr, user_id.clone(), &config, read, &write).fuse();
+                            // Create local state.
+                            let mut state = State::from(user);
+                            let user_id = state.cache.user_id.clone();
 
-        // Pin both tasks.
-        pin_mut!(listener, worker);
+                            // Create presence session.
+                            let (first_session, session_id) =
+                                presence_create_session(&user_id, 0).await;
 
-        // Wait for either disconnect or for listener to die.
-        select!(
-            () = listener => {},
-            () = worker => {}
-        );
-    }
-    // Clean up presence session.
-    let last_session = delete_session(&user_id, session_id).await;
+                            // Notify socket we have authenticated.
+                            write
+                                .lock()
+                                .await
+                                .send(config.encode(&EventV1::Authenticated))
+                                .await
+                                .ok();
 
-    // If this was the last session, notify other users that we just went offline.
-    if last_session {
-        state.broadcast_presence_change(false).await;
-    }
-}
-
-async fn listener(
-    db: &'static Database,
-    state: &mut State,
-    addr: SocketAddr,
-    config: &ProtocolConfiguration,
-    write: &Mutex<WsWriter>,
-) {
-    let redis_config = RedisConfig::from_url(&REDIS_URI).unwrap();
-    let Ok(subscriber) = fred::types::Builder::from_config(redis_config).build_subscriber_client()
-    else {
-        return;
-    };
-    if subscriber.init().await.is_err() {
-        return;
-    };
-    let mut message_rx = subscriber.message_rx();
-    loop {
-        // Check for state changes for subscriptions.
-        match state.apply_state() {
-            SubscriptionStateChange::Reset => {
-                subscriber.unsubscribe_all().await.unwrap();
-                for id in state.iter_subscriptions() {
-                    subscriber.subscribe(id).await.unwrap();
-                }
+                            // 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();
 
-                #[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}");
+                                // If this was the first session, notify other users that we just went online.
+                                if first_session {
+                                    state.broadcast_presence_change(true).await;
+                                }
 
-                    subscriber.unsubscribe(id).await.unwrap();
-                }
+                                // 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();
+                                                    }
 
-                for id in add {
-                    #[cfg(debug_assertions)]
-                    info!("{addr:?} subscribing to {id}");
+                                                    #[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}");
 
-                    subscriber.subscribe(id).await.unwrap();
-                }
-            }
-            SubscriptionStateChange::None => {}
-        }
+                                                        conn.unsubscribe(id).await.unwrap();
+                                                    }
 
-        // Handle incoming events.
-        let Ok(message) = message_rx.recv().await.map_err(|e| {
-            warn!("Error while consuming pub/sub messages: {e:?}");
-            sentry::capture_error(&e);
-        }) else {
-            return;
-        };
-        let event = match *REDIS_PAYLOAD_TYPE {
-            PayloadType::Json => message
-                .value
-                .as_str()
-                .and_then(|s| serde_json::from_str::<EventV1>(s.as_ref()).ok()),
-            PayloadType::Msgpack => message
-                .value
-                .as_bytes()
-                .and_then(|b| rmp_serde::from_slice::<EventV1>(b).ok()),
-            PayloadType::Bincode => message
-                .value
-                .as_bytes()
-                .and_then(|b| bincode::deserialize::<EventV1>(b).ok()),
-        };
-        let Some(mut event) = event else {
-            warn!("Failed to deserialise an event for {}!", message.channel);
-            return;
-        };
-        let should_send = state.handle_incoming_event_v1(db, &mut event).await;
-        if !should_send {
-            continue;
-        }
+                                                    for id in add {
+                                                        #[cfg(debug_assertions)]
+                                                        info!("{addr:?} subscribing to {id}");
 
-        let result = write.lock().await.send(config.encode(&event)).await;
-        if let Err(e) = result {
-            use async_tungstenite::tungstenite::Error;
-            if !matches!(e, Error::AlreadyClosed | Error::ConnectionClosed) {
-                warn!("Error while sending an event to {addr:?}: {e:?}");
-            }
-            return;
-        }
-    }
-}
-
-async fn worker(
-    addr: SocketAddr,
-    user_id: String,
-    config: &ProtocolConfiguration,
-    mut read: WsReader,
-    write: &Mutex<WsWriter>,
-) {
-    loop {
-        let result = read.try_next().await;
-        let msg = match result {
-            Ok(Some(msg)) => msg,
-            Ok(None) => return,
-            Err(e) => {
-                use async_tungstenite::tungstenite::Error;
-                if !matches!(e, Error::AlreadyClosed | Error::ConnectionClosed) {
-                    warn!("Error while reading an event from {addr:?}: {e:?}");
-                }
-                return;
-            }
-        };
-
-        let Ok(payload) = config.decode(&msg) else {
-            continue;
-        };
-        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();
+                                                        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/bridges/discord/Cargo.toml

@@ -0,0 +1,10 @@
+[package]
+name = "revolt-discord-bridge"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+serenity = { version = "0.11.5", default-features = false, features = ["client", "gateway", "rustls_backend", "model"] }
+tokio = { version = "1.0", features = ["macros", "rt-multi-thread"] }

crates/bridges/discord/src/main.rs

@@ -0,0 +1,45 @@
+use std::env;
+
+use serenity::async_trait;
+use serenity::model::channel::Message;
+use serenity::model::channel::Channel;
+use serenity::model::gateway::{GatewayIntents, Ready};
+use serenity::prelude::*;
+
+struct Handler;
+
+#[async_trait]
+impl EventHandler for Handler {
+    async fn message(&self, ctx: Context, msg: Message) {
+        println!("Received message: {}", msg.content);
+
+        if msg.content == "deez" {
+            if let Ok(Channel::Guild(channel)) = msg.channel(&ctx).await {
+                channel.send_message(&ctx, |m| {
+                    m.content("this is where a message would usually go")
+                }).await.unwrap();
+            }
+        }
+    }
+
+    async fn ready(&self, _: Context, ready: Ready) {
+        println!("{} is connected!", ready.user.name);
+    }
+}
+
+#[tokio::main]
+async fn main() {
+    let token = env::var("DISCORD_TOKEN").expect("Expected a token in the environment");
+
+    let intents =
+        GatewayIntents::GUILDS | GatewayIntents::GUILD_MESSAGES | GatewayIntents::MESSAGE_CONTENT;
+    
+    let mut client = Client::builder(token, intents)
+        .event_handler(Handler)
+        .await
+        .expect("Error creating client");
+
+    if let Err(why) = client.start().await {
+        println!("Client error: {:?}", why);
+    }
+}

crates/core/config/Cargo.toml

@@ -1,34 +0,0 @@
-[package]
-name = "revolt-config"
-version = "0.7.1"
-edition = "2021"
-license = "AGPL-3.0-or-later"
-authors = ["Paul Makles <me@insrt.uk>"]
-description = "Revolt Backend: Configuration"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[features]
-test = ["async-std"]
-default = ["test"]
-
-[dependencies]
-# Utility
-dotenv = "0.15.0"
-config = "0.13.3"
-cached = "0.44.0"
-once_cell = "1.18.0"
-
-# Serde
-serde = { version = "1", features = ["derive"] }
-
-# Async
-futures-locks = "0.7.1"
-async-std = { version = "1.8.0", features = ["attributes"], optional = true }
-
-# Logging
-log = "0.4.14"
-pretty_env_logger = "0.4.0"
-
-# Sentry
-sentry = "0.31.5"

crates/core/config/Revolt.test.toml

@@ -1,3 +0,0 @@
-[database]
-mongodb = "mongodb://localhost"
-redis = "redis://localhost/"

crates/core/config/Revolt.toml

@@ -1,70 +0,0 @@
-sentry_dsn = ""
-
-[database]
-mongodb = "mongodb://database"
-redis = "redis://redis/"
-
-[hosts]
-app = "http://local.revolt.chat"
-api = "http://local.revolt.chat/api"
-events = "ws://local.revolt.chat/ws"
-autumn = "http://local.revolt.chat/autumn"
-january = "http://local.revolt.chat/january"
-voso_legacy = ""
-voso_legacy_ws = ""
-
-[api]
-staging = false
-
-[api.registration]
-invite_only = false
-
-[api.smtp]
-host = ""
-username = ""
-password = ""
-from_address = ""
-
-[api.vapid]
-private_key = "LS0tLS1CRUdJTiBFQyBQUklWQVRFIEtFWS0tLS0tCk1IY0NBUUVFSUJSUWpyTWxLRnBiVWhsUHpUbERvcEliYk1yeVNrNXpKYzVYVzIxSjJDS3hvQW9HQ0NxR1NNNDkKQXdFSG9VUURRZ0FFWnkrQkg2TGJQZ2hEa3pEempXOG0rUXVPM3pCajRXT1phdkR6ZU00c0pqbmFwd1psTFE0WAp1ZDh2TzVodU94QWhMQlU3WWRldVovWHlBdFpWZmNyQi9BPT0KLS0tLS1FTkQgRUMgUFJJVkFURSBLRVktLS0tLQo"
-public_key = "BGcvgR-i2z4IQ5Mw841vJvkLjt8wY-FjmWrw83jOLCY52qcGZS0OF7nfLzuYbjsQISwVO2HXrmf18gLWVX3Kwfw="
-
-[api.fcm]
-api_key = ""
-
-[api.security]
-authifier_shield_key = ""
-voso_legacy_token = ""
-trust_cloudflare = false
-
-[api.security.captcha]
-hcaptcha_key = ""
-hcaptcha_sitekey = ""
-
-[api.workers]
-max_concurrent_connections = 50
-
-[features]
-webhooks_enabled = false
-
-[features.limits]
-
-[features.limits.default]
-group_size = 100
-bots = 5
-message_length = 2000
-message_embeds = 5
-message_replies = 5
-message_attachments = 5
-message_reactions = 20
-servers = 100
-server_emoji = 100
-server_roles = 200
-server_channels = 200
-
-attachment_size = 20000000
-avatar_size = 4000000
-background_size = 6000000
-icon_size = 2500000
-banner_size = 6000000
-emoji_size = 500000

crates/core/config/src/lib.rs

@@ -1,243 +0,0 @@
-use std::collections::HashMap;
-
-use cached::proc_macro::cached;
-use config::{Config, File, FileFormat};
-use futures_locks::RwLock;
-use once_cell::sync::Lazy;
-use serde::Deserialize;
-
-#[cfg(not(debug_assertions))]
-use std::env;
-
-static CONFIG_BUILDER: Lazy<RwLock<Config>> = Lazy::new(|| {
-    RwLock::new({
-        let mut builder = Config::builder().add_source(File::from_str(
-            include_str!("../Revolt.toml"),
-            FileFormat::Toml,
-        ));
-
-        if std::env::var("TEST_DB").is_ok() {
-            builder = builder.add_source(File::from_str(
-                include_str!("../Revolt.test.toml"),
-                FileFormat::Toml,
-            ));
-        } else if std::path::Path::new("Revolt.toml").exists() {
-            builder = builder.add_source(File::new("Revolt.toml", FileFormat::Toml));
-        }
-
-        builder.build().unwrap()
-    })
-});
-
-// https://gifbox.me/view/gT5mqxYKCZv-twilight-meow
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct Database {
-    pub mongodb: String,
-    pub redis: String,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct Hosts {
-    pub app: String,
-    pub api: String,
-    pub events: String,
-    pub autumn: String,
-    pub january: String,
-    pub voso_legacy: String,
-    pub voso_legacy_ws: String,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct ApiRegistration {
-    pub invite_only: bool,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct ApiSmtp {
-    pub host: String,
-    pub username: String,
-    pub password: String,
-    pub from_address: String,
-    pub reply_to: Option<String>,
-    pub port: Option<i32>,
-    pub use_tls: Option<bool>,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct ApiVapid {
-    pub private_key: String,
-    pub public_key: String,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct ApiFcm {
-    pub api_key: String,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct ApiSecurityCaptcha {
-    pub hcaptcha_key: String,
-    pub hcaptcha_sitekey: String,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct ApiSecurity {
-    pub authifier_shield_key: String,
-    pub voso_legacy_token: String,
-    pub captcha: ApiSecurityCaptcha,
-    pub trust_cloudflare: bool,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct ApiWorkers {
-    pub max_concurrent_connections: usize,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct Api {
-    pub staging: bool,
-    pub registration: ApiRegistration,
-    pub smtp: ApiSmtp,
-    pub vapid: ApiVapid,
-    pub fcm: ApiFcm,
-    pub security: ApiSecurity,
-    pub workers: ApiWorkers,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct FeaturesLimits {
-    pub group_size: usize,
-    pub bots: usize,
-    pub message_length: usize,
-    pub message_replies: usize,
-    pub message_attachments: usize,
-    pub message_embeds: usize,
-    pub message_reactions: usize,
-    pub servers: usize,
-    pub server_emoji: usize,
-    pub server_roles: usize,
-    pub server_channels: usize,
-
-    pub attachment_size: usize,
-    pub avatar_size: usize,
-    pub background_size: usize,
-    pub icon_size: usize,
-    pub banner_size: usize,
-    pub emoji_size: usize,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct FeaturesLimitsCollection {
-    pub default: FeaturesLimits,
-
-    #[serde(flatten)]
-    pub roles: HashMap<String, FeaturesLimits>,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct Features {
-    pub limits: FeaturesLimitsCollection,
-    pub webhooks_enabled: bool,
-}
-
-#[derive(Deserialize, Debug, Clone)]
-pub struct Settings {
-    pub database: Database,
-    pub hosts: Hosts,
-    pub api: Api,
-    pub features: Features,
-    pub sentry_dsn: String,
-}
-
-impl Settings {
-    pub fn preflight_checks(&self) {
-        if self.api.smtp.host.is_empty() {
-            #[cfg(not(debug_assertions))]
-            if !env::var("REVOLT_UNSAFE_NO_EMAIL").map_or(false, |v| v == *"1") {
-                panic!("Running in production without email is not recommended, set REVOLT_UNSAFE_NO_EMAIL=1 to override.");
-            }
-
-            #[cfg(debug_assertions)]
-            log::warn!("No SMTP settings specified! Remember to configure email.");
-        }
-
-        if self.api.security.captcha.hcaptcha_key.is_empty() {
-            #[cfg(not(debug_assertions))]
-            if !env::var("REVOLT_UNSAFE_NO_CAPTCHA").map_or(false, |v| v == *"1") {
-                panic!("Running in production without CAPTCHA is not recommended, set REVOLT_UNSAFE_NO_CAPTCHA=1 to override.");
-            }
-
-            #[cfg(debug_assertions)]
-            log::warn!("No Captcha key specified! Remember to add hCaptcha key.");
-        }
-    }
-}
-
-pub async fn init() {
-    println!(
-        ":: Revolt Configuration ::\n\x1b[32m{:?}\x1b[0m",
-        config().await
-    );
-}
-
-pub async fn read() -> Config {
-    CONFIG_BUILDER.read().await.clone()
-}
-
-#[cached(time = 30)]
-pub async fn config() -> Settings {
-    read().await.try_deserialize::<Settings>().unwrap()
-}
-
-/// Configure logging and common Rust variables
-pub async fn setup_logging(release: &'static str) -> Option<sentry::ClientInitGuard> {
-    dotenv::dotenv().ok();
-
-    if std::env::var("RUST_LOG").is_err() {
-        std::env::set_var("RUST_LOG", "info");
-    }
-
-    if std::env::var("ROCKET_ADDRESS").is_err() {
-        std::env::set_var("ROCKET_ADDRESS", "0.0.0.0");
-    }
-
-    pretty_env_logger::init();
-    log::info!("Starting {release}");
-
-    let config = config().await;
-    if config.sentry_dsn.is_empty() {
-        None
-    } else {
-        Some(sentry::init((
-            config.sentry_dsn,
-            sentry::ClientOptions {
-                release: Some(release.into()),
-                ..Default::default()
-            },
-        )))
-    }
-}
-
-#[macro_export]
-macro_rules! configure {
-    () => {
-        let _sentry = $crate::setup_logging(concat!(
-            env!("CARGO_PKG_NAME"),
-            "@",
-            env!("CARGO_PKG_VERSION")
-        ))
-        .await;
-    };
-}
-
-#[cfg(feature = "test")]
-#[cfg(test)]
-mod tests {
-    use crate::init;
-
-    #[async_std::test]
-    async fn it_works() {
-        init().await;
-    }
-}

crates/core/database/Cargo.toml

@@ -1,92 +0,0 @@
-[package]
-name = "revolt-database"
-version = "0.7.1"
-edition = "2021"
-license = "AGPL-3.0-or-later"
-authors = ["Paul Makles <me@insrt.uk>"]
-description = "Revolt Backend: Database Implementation"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
-[features]
-# Databases
-mongodb = ["dep:mongodb", "bson"]
-
-# ... Other
-tasks = ["isahc", "linkify", "url-escape"]
-async-std-runtime = ["async-std"]
-rocket-impl = ["rocket", "schemars", "revolt_okapi", "revolt_rocket_okapi"]
-redis-is-patched = ["revolt-presence/redis-is-patched"]
-
-# Default Features
-default = ["mongodb", "async-std-runtime", "tasks"]
-
-[dependencies]
-# Core
-revolt-config = { version = "0.7.1", path = "../config" }
-revolt-result = { version = "0.7.1", path = "../result" }
-revolt-models = { version = "0.7.1", path = "../models", features = [
-    "validator",
-] }
-revolt-presence = { version = "0.7.1", path = "../presence" }
-revolt-permissions = { version = "0.7.1", path = "../permissions", features = [
-    "serde",
-    "bson",
-] }
-
-# Utility
-log = "0.4"
-lru = "0.11.0"
-rand = "0.8.5"
-ulid = "1.0.0"
-nanoid = "0.4.0"
-base64 = "0.21.3"
-once_cell = "1.17"
-indexmap = "1.9.1"
-decancer = "1.6.2"
-deadqueue = "0.2.4"
-linkify = { optional = true, version = "0.8.1" }
-url-escape = { optional = true, version = "0.1.1" }
-validator = { version = "0.16", features = ["derive"] }
-isahc = { optional = true, version = "1.7", features = ["json"] }
-
-# Serialisation
-serde_json = "1"
-revolt_optional_struct = "0.2.0"
-serde = { version = "1", features = ["derive"] }
-iso8601-timestamp = { version = "0.2.10", features = ["serde", "bson"] }
-
-# Events
-redis-kiss = { version = "0.1.4" }
-
-# Database
-bson = { optional = true, version = "2.1.0" }
-mongodb = { optional = true, version = "2.1.0", default-features = false }
-
-# Database Migration
-unicode-segmentation = "1.10.1"
-regex = "1"
-
-# Async Language Features
-futures = "0.3.19"
-async-lock = "2.8.0"
-async-trait = "0.1.51"
-async-recursion = "1.0.4"
-
-# Async
-async-std = { version = "1.8.0", features = ["attributes"], optional = true }
-
-# Rocket Impl
-schemars = { version = "0.8.8", optional = true }
-rocket = { version = "0.5.0-rc.2", default-features = false, features = [
-    "json",
-], optional = true }
-revolt_okapi = { version = "0.9.1", optional = true }
-revolt_rocket_okapi = { version = "0.9.1", optional = true }
-
-# Notifications
-fcm = "0.9.2"
-web-push = "0.10.0"
-
-# Authifier
-authifier = { version = "1.0.8" }

crates/core/database/fixtures/group_with_members.json

@@ -1,28 +0,0 @@
-[
-  {
-    "_object_type": "User",
-    "_id": "__ID:0__",
-    "username": "Owner",
-    "discriminator": "0001"
-  },
-  {
-    "_object_type": "User",
-    "_id": "__ID:1__",
-    "username": "Member",
-    "discriminator": "0001"
-  },
-  {
-    "_object_type": "User",
-    "_id": "__ID:2__",
-    "username": "Member",
-    "discriminator": "0002"
-  },
-  {
-    "_object_type": "Channel",
-    "_id": "__ID:3__",
-    "channel_type": "Group",
-    "name": "My Group",
-    "owner": "__ID:0__",
-    "recipients": ["__ID:0__", "__ID:1__"]
-  }
-]

crates/core/database/fixtures/server_with_roles.json

@@ -1,89 +0,0 @@
-[
-  {
-    "_object_type": "User",
-    "_id": "__ID:0__",
-    "username": "Owner",
-    "discriminator": "0001"
-  },
-  {
-    "_object_type": "User",
-    "_id": "__ID:1__",
-    "username": "Moderator",
-    "discriminator": "0001"
-  },
-  {
-    "_object_type": "User",
-    "_id": "__ID:2__",
-    "username": "User",
-    "discriminator": "0001"
-  },
-  {
-    "_object_type": "Channel",
-    "_id": "__ID:3__",
-    "channel_type": "TextChannel",
-    "name": "General",
-    "server": "__ID:4__",
-    "default_permissions": {
-      "a": 0,
-      "d": 1048576
-    },
-    "role_permissions": {
-      "__ID:5__": {
-        "a": 1048576,
-        "d": 0
-      }
-    }
-  },
-  {
-    "_object_type": "Server",
-    "_id": "__ID:4__",
-    "owner": "__ID:0__",
-    "name": "Server",
-    "channels": ["__ID:3__"],
-    "roles": {
-      "__ID:5__": {
-        "name": "Moderator",
-        "permissions": {
-          "a": 545270208,
-          "d": 0
-        },
-        "rank": 3
-      },
-      "__ID:6__": {
-        "name": "Owner",
-        "permissions": {
-          "a": 0,
-          "d": 0
-        },
-        "rank": 0
-      }
-    },
-    "default_permissions": 4000322560
-  },
-  {
-    "_object_type": "ServerMember",
-    "_id": {
-      "user": "__ID:0__",
-      "server": "__ID:4__"
-    },
-    "roles": ["__ID:6__"],
-    "joined_at": 1698318340195
-  },
-  {
-    "_object_type": "ServerMember",
-    "_id": {
-      "user": "__ID:1__",
-      "server": "__ID:4__"
-    },
-    "roles": ["__ID:5__"],
-    "joined_at": 1698318340195
-  },
-  {
-    "_object_type": "ServerMember",
-    "_id": {
-      "user": "__ID:2__",
-      "server": "__ID:4__"
-    },
-    "joined_at": 1698318340195
-  }
-]

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

@@ -1,89 +0,0 @@
-mod mongodb;
-mod reference;
-
-use rand::Rng;
-use revolt_config::config;
-
-pub use self::mongodb::*;
-pub use self::reference::*;
-
-/// Database information to use to create a client
-pub enum DatabaseInfo {
-    /// Auto-detect the database in use
-    Auto,
-    /// Auto-detect the database in use and create an empty testing database
-    Test(String),
-    /// Use the mock database
-    Reference,
-    /// Connect to MongoDB
-    MongoDb { uri: String, database_name: String },
-    /// Use existing MongoDB connection
-    MongoDbFromClient(::mongodb::Client, String),
-}
-
-/// Database
-#[derive(Clone)]
-pub enum Database {
-    /// Mock database
-    Reference(ReferenceDb),
-    /// MongoDB database
-    MongoDb(MongoDb),
-}
-
-impl DatabaseInfo {
-    /// Create a database client from the given database information
-    #[async_recursion]
-    pub async fn connect(self) -> Result<Database, String> {
-        let config = config().await;
-
-        Ok(match self {
-            DatabaseInfo::Auto => {
-                if std::env::var("TEST_DB").is_ok() {
-                    DatabaseInfo::Test(format!(
-                        "revolt_test_{}",
-                        rand::thread_rng().gen_range(1_000_000..10_000_000)
-                    ))
-                    .connect()
-                    .await?
-                } else if !config.database.mongodb.is_empty() {
-                    DatabaseInfo::MongoDb {
-                        uri: config.database.mongodb,
-                        database_name: "revolt".to_string(),
-                    }
-                    .connect()
-                    .await?
-                } else {
-                    DatabaseInfo::Reference.connect().await?
-                }
-            }
-            DatabaseInfo::Test(database_name) => {
-                match std::env::var("TEST_DB")
-                    .expect("`TEST_DB` environment variable should be set to REFERENCE or MONGODB")
-                    .as_str()
-                {
-                    "REFERENCE" => DatabaseInfo::Reference.connect().await?,
-                    "MONGODB" => {
-                        DatabaseInfo::MongoDb {
-                            uri: config.database.mongodb,
-                            database_name,
-                        }
-                        .connect()
-                        .await?
-                    }
-                    _ => unreachable!("must specify REFERENCE or MONGODB"),
-                }
-            }
-            DatabaseInfo::Reference => Database::Reference(Default::default()),
-            DatabaseInfo::MongoDb { uri, database_name } => {
-                let client = ::mongodb::Client::with_uri_str(uri)
-                    .await
-                    .map_err(|_| "Failed to init db connection.".to_string())?;
-
-                Database::MongoDb(MongoDb(client, database_name))
-            }
-            DatabaseInfo::MongoDbFromClient(client, database_name) => {
-                Database::MongoDb(MongoDb(client, database_name))
-            }
-        })
-    }
-}

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

@@ -1,32 +0,0 @@
-use std::{collections::HashMap, sync::Arc};
-
-use futures::lock::Mutex;
-
-use crate::{
-    Bot, Channel, ChannelCompositeKey, ChannelUnread, Emoji, File, Invite, Member,
-    MemberCompositeKey, Message, RatelimitEvent, Report, Server, ServerBan, Snapshot, User,
-    UserSettings, Webhook,
-};
-
-database_derived!(
-    /// Reference implementation
-    #[derive(Default)]
-    pub struct ReferenceDb {
-        pub bots: Arc<Mutex<HashMap<String, Bot>>>,
-        pub channels: Arc<Mutex<HashMap<String, Channel>>>,
-        pub channel_invites: Arc<Mutex<HashMap<String, Invite>>>,
-        pub channel_unreads: Arc<Mutex<HashMap<ChannelCompositeKey, ChannelUnread>>>,
-        pub channel_webhooks: Arc<Mutex<HashMap<String, Webhook>>>,
-        pub emojis: Arc<Mutex<HashMap<String, Emoji>>>,
-        pub files: Arc<Mutex<HashMap<String, File>>>,
-        pub messages: Arc<Mutex<HashMap<String, Message>>>,
-        pub ratelimit_events: Arc<Mutex<HashMap<String, RatelimitEvent>>>,
-        pub user_settings: Arc<Mutex<HashMap<String, UserSettings>>>,
-        pub users: Arc<Mutex<HashMap<String, User>>>,
-        pub server_bans: Arc<Mutex<HashMap<MemberCompositeKey, ServerBan>>>,
-        pub server_members: Arc<Mutex<HashMap<MemberCompositeKey, Member>>>,
-        pub servers: Arc<Mutex<HashMap<String, Server>>>,
-        pub safety_reports: Arc<Mutex<HashMap<String, Report>>>,
-        pub safety_snapshots: Arc<Mutex<HashMap<String, Snapshot>>>,
-    }
-);

crates/core/database/src/lib.rs

@@ -1,89 +0,0 @@
-#[macro_use]
-extern crate serde;
-
-#[macro_use]
-extern crate async_recursion;
-
-#[macro_use]
-extern crate async_trait;
-
-#[macro_use]
-extern crate log;
-
-#[macro_use]
-extern crate revolt_optional_struct;
-
-#[macro_use]
-extern crate revolt_result;
-
-#[cfg(feature = "mongodb")]
-pub use mongodb;
-
-#[cfg(feature = "mongodb")]
-#[macro_use]
-extern crate bson;
-
-macro_rules! database_derived {
-    ( $( $item:item )+ ) => {
-        $(
-            #[derive(Clone)]
-            $item
-        )+
-    };
-}
-
-macro_rules! auto_derived {
-    ( $( $item:item )+ ) => {
-        $(
-            #[derive(Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
-            $item
-        )+
-    };
-}
-
-macro_rules! auto_derived_partial {
-    ( $item:item, $name:expr ) => {
-        #[derive(OptionalStruct, Serialize, Deserialize, Debug, Clone, Eq, PartialEq)]
-        #[optional_derive(Serialize, Deserialize, Debug, Clone, Default, Eq, PartialEq)]
-        #[optional_name = $name]
-        #[opt_skip_serializing_none]
-        #[opt_some_priority]
-        $item
-    };
-}
-
-mod drivers;
-pub use drivers::*;
-
-#[cfg(test)]
-macro_rules! database_test {
-    ( | $db: ident | $test:expr ) => {
-        let db = $crate::DatabaseInfo::Test(format!(
-            "{}:{}",
-            file!().replace('/', "_").replace(".rs", ""),
-            line!()
-        ))
-        .connect()
-        .await
-        .expect("Database connection failed.");
-
-        db.drop_database().await;
-
-        #[allow(clippy::redundant_closure_call)]
-        (|$db: $crate::Database| $test)(db.clone()).await;
-
-        db.drop_database().await
-    };
-}
-
-mod models;
-pub mod util;
-pub use models::*;
-
-pub mod events;
-pub mod tasks;
-
-/// Utility function to check if a boolean value is false
-pub fn if_false(t: &bool) -> bool {
-    !t
-}

crates/core/database/src/models/admin_migrations/mod.rs

@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;

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

@@ -1,24 +0,0 @@
-auto_derived!(
-    /// Document representing migration information
-    pub struct MigrationInfo {
-        /// Unique Id
-        #[serde(rename = "_id")]
-        pub id: i32,
-        /// Current database revision
-        pub revision: i32,
-    }
-);
-
-#[cfg(test)]
-mod tests {
-    #[async_std::test]
-    async fn migrate() {
-        database_test!(|db| async move {
-            // Initialise the database
-            db.migrate_database().await.unwrap();
-
-            // Migrate the existing database
-            db.migrate_database().await.unwrap();
-        });
-    }
-}

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

@@ -1,12 +0,0 @@
-mod mongodb;
-mod reference;
-
-#[async_trait]
-pub trait AbstractMigrations: Sync + Send {
-    #[cfg(test)]
-    /// Drop the database
-    async fn drop_database(&self);
-
-    /// Migrate the database
-    async fn migrate_database(&self) -> Result<(), ()>;
-}

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

@@ -1,16 +0,0 @@
-use crate::ReferenceDb;
-
-use super::AbstractMigrations;
-
-#[async_trait]
-impl AbstractMigrations for ReferenceDb {
-    #[cfg(test)]
-    /// Drop the database
-    async fn drop_database(&self) {}
-
-    /// Migrate the database
-    async fn migrate_database(&self) -> Result<(), ()> {
-        // Here you would do your typical migrations if this was a real database.
-        Ok(())
-    }
-}

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

@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;

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

@@ -1,215 +0,0 @@
-use revolt_config::config;
-use revolt_result::Result;
-use ulid::Ulid;
-
-use crate::{BotInformation, Database, PartialUser, User};
-
-auto_derived_partial!(
-    /// Bot
-    pub struct Bot {
-        /// Bot Id
-        ///
-        /// This equals the associated bot user's id.
-        #[serde(rename = "_id")]
-        pub id: String,
-        /// User Id of the bot owner
-        pub owner: String,
-        /// Token used to authenticate requests for this bot
-        pub token: String,
-        /// Whether the bot is public
-        /// (may be invited by anyone)
-        pub public: bool,
-
-        /// Whether to enable analytics
-        #[serde(skip_serializing_if = "crate::if_false", default)]
-        pub analytics: bool,
-        /// Whether this bot should be publicly discoverable
-        #[serde(skip_serializing_if = "crate::if_false", default)]
-        pub discoverable: bool,
-        /// Reserved; URL for handling interactions
-        #[serde(skip_serializing_if = "String::is_empty", default)]
-        pub interactions_url: String,
-        /// URL for terms of service
-        #[serde(skip_serializing_if = "String::is_empty", default)]
-        pub terms_of_service_url: String,
-        /// URL for privacy policy
-        #[serde(skip_serializing_if = "String::is_empty", default)]
-        pub privacy_policy_url: String,
-
-        /// Enum of bot flags
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub flags: Option<i32>,
-    },
-    "PartialBot"
-);
-
-auto_derived!(
-    /// Optional fields on bot object
-    pub enum FieldsBot {
-        Token,
-        InteractionsURL,
-    }
-);
-
-#[allow(clippy::derivable_impls)]
-impl Default for Bot {
-    fn default() -> Self {
-        Self {
-            id: Default::default(),
-            owner: Default::default(),
-            token: Default::default(),
-            public: Default::default(),
-            analytics: Default::default(),
-            discoverable: Default::default(),
-            interactions_url: Default::default(),
-            terms_of_service_url: Default::default(),
-            privacy_policy_url: Default::default(),
-            flags: Default::default(),
-        }
-    }
-}
-
-#[allow(clippy::disallowed_methods)]
-impl Bot {
-    /// Create a new bot
-    pub async fn create<D>(db: &Database, username: String, owner: &User, data: D) -> Result<Bot>
-    where
-        D: Into<Option<PartialBot>>,
-    {
-        if owner.bot.is_some() {
-            return Err(create_error!(IsBot));
-        }
-
-        let config = config().await;
-        if db.get_number_of_bots_by_user(&owner.id).await? >= config.features.limits.default.bots {
-            return Err(create_error!(ReachedMaximumBots));
-        }
-
-        let id = Ulid::new().to_string();
-
-        User::create(
-            db,
-            username,
-            Some(id.to_string()),
-            Some(PartialUser {
-                bot: Some(BotInformation {
-                    owner: owner.id.to_string(),
-                }),
-                ..Default::default()
-            }),
-        )
-        .await?;
-
-        let mut bot = Bot {
-            id,
-            owner: owner.id.to_string(),
-            token: nanoid::nanoid!(64),
-            ..Default::default()
-        };
-
-        if let Some(data) = data.into() {
-            bot.apply_options(data);
-        }
-
-        db.insert_bot(&bot).await?;
-        Ok(bot)
-    }
-
-    /// Remove a field from this object
-    pub fn remove_field(&mut self, field: &FieldsBot) {
-        match field {
-            FieldsBot::Token => self.token = nanoid::nanoid!(64),
-            FieldsBot::InteractionsURL => {
-                self.interactions_url = String::new();
-            }
-        }
-    }
-
-    /// Update this bot
-    pub async fn update(
-        &mut self,
-        db: &Database,
-        mut partial: PartialBot,
-        remove: Vec<FieldsBot>,
-    ) -> Result<()> {
-        if remove.contains(&FieldsBot::Token) {
-            partial.token = Some(nanoid::nanoid!(64));
-        }
-
-        for field in &remove {
-            self.remove_field(field);
-        }
-
-        db.update_bot(&self.id, &partial, remove).await?;
-
-        self.apply_options(partial);
-        Ok(())
-    }
-
-    /// Delete this bot
-    pub async fn delete(&self, db: &Database) -> Result<()> {
-        db.fetch_user(&self.id).await?.mark_deleted(db).await?;
-        db.delete_bot(&self.id).await
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::{Bot, FieldsBot, PartialBot, User};
-
-    #[async_std::test]
-    async fn crud() {
-        database_test!(|db| async move {
-            let owner = User::create(&db, "Owner".to_string(), None, None)
-                .await
-                .unwrap();
-
-            let bot = Bot::create(
-                &db,
-                "Bot Name".to_string(),
-                &owner,
-                PartialBot {
-                    token: Some("my token".to_string()),
-                    interactions_url: Some("some url".to_string()),
-                    ..Default::default()
-                },
-            )
-            .await
-            .unwrap();
-
-            assert!(!bot.interactions_url.is_empty());
-
-            let mut updated_bot = bot.clone();
-            updated_bot
-                .update(
-                    &db,
-                    PartialBot {
-                        public: Some(true),
-                        ..Default::default()
-                    },
-                    vec![FieldsBot::Token, FieldsBot::InteractionsURL],
-                )
-                .await
-                .unwrap();
-
-            let fetched_bot1 = db.fetch_bot(&bot.id).await.unwrap();
-            let fetched_bot2 = db.fetch_bot_by_token(&fetched_bot1.token).await.unwrap();
-            let fetched_bots = db.fetch_bots_by_user(&owner.id).await.unwrap();
-
-            assert!(!bot.public);
-            assert!(fetched_bot1.public);
-            assert!(!bot.interactions_url.is_empty());
-            assert!(fetched_bot1.interactions_url.is_empty());
-            assert_ne!(bot.token, fetched_bot1.token);
-            assert_eq!(updated_bot, fetched_bot1);
-            assert_eq!(fetched_bot1, fetched_bot2);
-            assert_eq!(fetched_bot1, fetched_bots[0]);
-            assert_eq!(1, db.get_number_of_bots_by_user(&owner.id).await.unwrap());
-
-            bot.delete(&db).await.unwrap();
-            assert!(db.fetch_bot(&bot.id).await.is_err());
-            assert_eq!(0, db.get_number_of_bots_by_user(&owner.id).await.unwrap());
-            assert_eq!(db.fetch_user(&bot.id).await.unwrap().flags, Some(2))
-        });
-    }
-}

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

@@ -1,92 +0,0 @@
-use revolt_result::Result;
-
-use crate::{Bot, FieldsBot, PartialBot};
-use crate::{IntoDocumentPath, MongoDb};
-
-use super::AbstractBots;
-
-static COL: &str = "bots";
-
-#[async_trait]
-impl AbstractBots for MongoDb {
-    /// Insert new bot into the database
-    async fn insert_bot(&self, bot: &Bot) -> Result<()> {
-        query!(self, insert_one, COL, &bot).map(|_| ())
-    }
-
-    /// Fetch a bot by its id
-    async fn fetch_bot(&self, id: &str) -> Result<Bot> {
-        query!(self, find_one_by_id, COL, id)?.ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch a bot by its token
-    async fn fetch_bot_by_token(&self, token: &str) -> Result<Bot> {
-        query!(
-            self,
-            find_one,
-            COL,
-            doc! {
-                "token": token
-            }
-        )?
-        .ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch bots owned by a user
-    async fn fetch_bots_by_user(&self, user_id: &str) -> Result<Vec<Bot>> {
-        query!(
-            self,
-            find,
-            COL,
-            doc! {
-                "owner": user_id
-            }
-        )
-    }
-
-    /// Get the number of bots owned by a user
-    async fn get_number_of_bots_by_user(&self, user_id: &str) -> Result<usize> {
-        query!(
-            self,
-            count_documents,
-            COL,
-            doc! {
-                "owner": user_id
-            }
-        )
-        .map(|v| v as usize)
-    }
-
-    /// Update bot with new information
-    async fn update_bot(
-        &self,
-        id: &str,
-        partial: &PartialBot,
-        remove: Vec<FieldsBot>,
-    ) -> Result<()> {
-        query!(
-            self,
-            update_one_by_id,
-            COL,
-            id,
-            partial,
-            remove.iter().map(|x| x as &dyn IntoDocumentPath).collect(),
-            None
-        )
-        .map(|_| ())
-    }
-
-    /// Delete a bot from the database
-    async fn delete_bot(&self, id: &str) -> Result<()> {
-        query!(self, delete_one_by_id, COL, id).map(|_| ())
-    }
-}
-
-impl IntoDocumentPath for FieldsBot {
-    fn as_path(&self) -> Option<&'static str> {
-        match self {
-            FieldsBot::InteractionsURL => Some("interactions_url"),
-            FieldsBot::Token => None,
-        }
-    }
-}

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

@@ -1,82 +0,0 @@
-use revolt_result::Result;
-
-use crate::ReferenceDb;
-use crate::{Bot, FieldsBot, PartialBot};
-
-use super::AbstractBots;
-
-#[async_trait]
-impl AbstractBots for ReferenceDb {
-    /// Insert new bot into the database
-    async fn insert_bot(&self, bot: &Bot) -> Result<()> {
-        let mut bots = self.bots.lock().await;
-        if bots.contains_key(&bot.id) {
-            Err(create_database_error!("insert", "bot"))
-        } else {
-            bots.insert(bot.id.to_string(), bot.clone());
-            Ok(())
-        }
-    }
-
-    /// Fetch a bot by its id
-    async fn fetch_bot(&self, id: &str) -> Result<Bot> {
-        let bots = self.bots.lock().await;
-        bots.get(id).cloned().ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch a bot by its token
-    async fn fetch_bot_by_token(&self, token: &str) -> Result<Bot> {
-        let bots = self.bots.lock().await;
-        bots.values()
-            .find(|bot| bot.token == token)
-            .cloned()
-            .ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch bots owned by a user
-    async fn fetch_bots_by_user(&self, user_id: &str) -> Result<Vec<Bot>> {
-        let bots = self.bots.lock().await;
-        Ok(bots
-            .values()
-            .filter(|bot| bot.owner == user_id)
-            .cloned()
-            .collect())
-    }
-
-    /// Get the number of bots owned by a user
-    async fn get_number_of_bots_by_user(&self, user_id: &str) -> Result<usize> {
-        let bots = self.bots.lock().await;
-        Ok(bots.values().filter(|bot| bot.owner == user_id).count())
-    }
-
-    /// Update bot with new information
-    async fn update_bot(
-        &self,
-        id: &str,
-        partial: &PartialBot,
-        remove: Vec<FieldsBot>,
-    ) -> Result<()> {
-        let mut bots = self.bots.lock().await;
-        if let Some(bot) = bots.get_mut(id) {
-            for field in remove {
-                #[allow(clippy::disallowed_methods)]
-                bot.remove_field(&field);
-            }
-
-            bot.apply_options(partial.clone());
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Delete a bot from the database
-    async fn delete_bot(&self, id: &str) -> Result<()> {
-        let mut bots = self.bots.lock().await;
-        if bots.remove(id).is_some() {
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-}

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

@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;

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

@@ -1,50 +0,0 @@
-use futures::StreamExt;
-use revolt_result::Result;
-
-use crate::Invite;
-use crate::MongoDb;
-
-use super::AbstractChannelInvites;
-
-static COL: &str = "channel_invites";
-
-#[async_trait]
-impl AbstractChannelInvites for MongoDb {
-    /// Insert a new invite into the database
-    async fn insert_invite(&self, invite: &Invite) -> Result<()> {
-        query!(self, insert_one, COL, &invite).map(|_| ())
-    }
-
-    /// Fetch an invite by the code
-    async fn fetch_invite(&self, code: &str) -> Result<Invite> {
-        query!(self, find_one_by_id, COL, code)?.ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch all invites for a server
-    async fn fetch_invites_for_server(&self, server_id: &str) -> Result<Vec<Invite>> {
-        Ok(self
-            .col::<Invite>(COL)
-            .find(
-                doc! {
-                    "server": server_id,
-                },
-                None,
-            )
-            .await
-            .map_err(|_| create_database_error!("find", COL))?
-            .filter_map(|s| async {
-                if cfg!(debug_assertions) {
-                    Some(s.unwrap())
-                } else {
-                    s.ok()
-                }
-            })
-            .collect()
-            .await)
-    }
-
-    /// Delete an invite by its code
-    async fn delete_invite(&self, code: &str) -> Result<()> {
-        query!(self, delete_one_by_id, COL, code).map(|_| ())
-    }
-}

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

@@ -1,52 +0,0 @@
-use revolt_result::Result;
-
-use crate::Invite;
-use crate::ReferenceDb;
-
-use super::AbstractChannelInvites;
-
-#[async_trait]
-impl AbstractChannelInvites for ReferenceDb {
-    /// Insert a new invite into the database
-    async fn insert_invite(&self, invite: &Invite) -> Result<()> {
-        let mut invites = self.channel_invites.lock().await;
-        if invites.contains_key(invite.code()) {
-            Err(create_database_error!("insert", "invite"))
-        } else {
-            invites.insert(invite.code().to_string(), invite.clone());
-            Ok(())
-        }
-    }
-
-    /// Fetch an invite by the code
-    async fn fetch_invite(&self, code: &str) -> Result<Invite> {
-        let invites = self.channel_invites.lock().await;
-        invites
-            .get(code)
-            .cloned()
-            .ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch all invites for a server
-    async fn fetch_invites_for_server(&self, server_id: &str) -> Result<Vec<Invite>> {
-        let invites = self.channel_invites.lock().await;
-        Ok(invites
-            .values()
-            .filter(|invite| match invite {
-                Invite::Server { server, .. } => server == server_id,
-                _ => false,
-            })
-            .cloned()
-            .collect())
-    }
-
-    /// Delete an invite by its code
-    async fn delete_invite(&self, code: &str) -> Result<()> {
-        let mut invites = self.channel_invites.lock().await;
-        if invites.remove(code).is_some() {
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-}

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

@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;

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

@@ -1,24 +0,0 @@
-auto_derived!(
-    /// Channel Unread
-    pub struct ChannelUnread {
-        /// Composite key pointing to a user's view of a channel
-        #[serde(rename = "_id")]
-        pub id: ChannelCompositeKey,
-
-        /// Id of the last message read in this channel by a user
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub last_id: Option<String>,
-        /// Array of message ids that mention the user
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub mentions: Option<Vec<String>>,
-    }
-
-    /// Composite primary key consisting of channel and user id
-    #[derive(Hash)]
-    pub struct ChannelCompositeKey {
-        /// Channel Id
-        pub channel: String,
-        /// User Id
-        pub user: String,
-    }
-);

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

@@ -1,31 +0,0 @@
-use revolt_result::Result;
-
-use crate::ChannelUnread;
-
-mod mongodb;
-mod reference;
-
-#[async_trait]
-pub trait AbstractChannelUnreads: Sync + Send {
-    /// Acknowledge a message.
-    async fn acknowledge_message(
-        &self,
-        channel_id: &str,
-        user_id: &str,
-        message_id: &str,
-    ) -> Result<()>;
-
-    /// Acknowledge many channels.
-    async fn acknowledge_channels(&self, user_id: &str, channel_ids: &[String]) -> Result<()>;
-
-    /// Add a mention.
-    async fn add_mention_to_unread<'a>(
-        &self,
-        channel_id: &str,
-        user_id: &str,
-        message_ids: &[String],
-    ) -> Result<()>;
-
-    /// Fetch all channel unreads for a user.
-    async fn fetch_unreads(&self, user_id: &str) -> Result<Vec<ChannelUnread>>;
-}

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

@@ -1,90 +0,0 @@
-use revolt_result::Result;
-use ulid::Ulid;
-
-use crate::{ChannelCompositeKey, ChannelUnread, ReferenceDb};
-
-use super::AbstractChannelUnreads;
-
-#[async_trait]
-impl AbstractChannelUnreads for ReferenceDb {
-    /// Acknowledge a message.
-    async fn acknowledge_message(
-        &self,
-        channel_id: &str,
-        user_id: &str,
-        message_id: &str,
-    ) -> Result<()> {
-        let mut unreads = self.channel_unreads.lock().await;
-        let key = ChannelCompositeKey {
-            channel: channel_id.to_string(),
-            user: user_id.to_string(),
-        };
-
-        if let Some(unread) = unreads.get_mut(&key) {
-            unread.mentions = None;
-            unread.last_id.replace(message_id.to_string());
-        } else {
-            unreads.insert(
-                key.clone(),
-                ChannelUnread {
-                    id: key,
-                    last_id: Some(message_id.to_string()),
-                    mentions: None,
-                },
-            );
-        }
-
-        Ok(())
-    }
-
-    /// Acknowledge many channels.
-    async fn acknowledge_channels(&self, user_id: &str, channel_ids: &[String]) -> Result<()> {
-        let current_time = Ulid::new().to_string();
-        for channel_id in channel_ids {
-            #[allow(clippy::disallowed_methods)]
-            self.acknowledge_message(channel_id, user_id, &current_time)
-                .await?;
-        }
-
-        Ok(())
-    }
-
-    /// Add a mention.
-    async fn add_mention_to_unread<'a>(
-        &self,
-        channel_id: &str,
-        user_id: &str,
-        message_ids: &[String],
-    ) -> Result<()> {
-        let mut unreads = self.channel_unreads.lock().await;
-        let key = ChannelCompositeKey {
-            channel: channel_id.to_string(),
-            user: user_id.to_string(),
-        };
-
-        if let Some(unread) = unreads.get_mut(&key) {
-            unread.mentions.replace(message_ids.to_vec());
-        } else {
-            unreads.insert(
-                key.clone(),
-                ChannelUnread {
-                    id: key,
-                    last_id: None,
-                    mentions: Some(message_ids.to_vec()),
-                },
-            );
-        }
-
-        Ok(())
-    }
-
-    /// Fetch all channel unreads for a user.
-    async fn fetch_unreads(&self, user_id: &str) -> Result<Vec<ChannelUnread>> {
-        let unreads = self.channel_unreads.lock().await;
-        Ok(unreads
-            .values()
-            .filter(|unread| unread.id.user == user_id)
-            .cloned()
-            .collect())
-    }
-}

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

@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;

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

@@ -1,175 +0,0 @@
-use revolt_result::Result;
-
-use crate::events::client::EventV1;
-use crate::{Database, File};
-
-auto_derived_partial!(
-    /// Webhook
-    pub struct Webhook {
-        /// Webhook Id
-        #[serde(rename = "_id")]
-        pub id: String,
-
-        /// The name of the webhook
-        pub name: String,
-
-        /// The avatar of the webhook
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub avatar: Option<File>,
-
-        /// The channel this webhook belongs to
-        pub channel_id: String,
-
-        /// The permissions of the webhook
-        pub permissions: u64,
-
-        /// The private token for the webhook
-        pub token: Option<String>,
-    },
-    "PartialWebhook"
-);
-
-auto_derived!(
-    /// Optional fields on webhook object
-    pub enum FieldsWebhook {
-        Avatar,
-    }
-);
-
-#[allow(clippy::derivable_impls)]
-impl Default for Webhook {
-    fn default() -> Self {
-        Self {
-            id: Default::default(),
-            name: Default::default(),
-            avatar: None,
-            channel_id: Default::default(),
-            permissions: Default::default(),
-            token: Default::default(),
-        }
-    }
-}
-
-#[allow(clippy::disallowed_methods)]
-impl Webhook {
-    pub async fn create(&self, db: &Database) -> Result<()> {
-        db.insert_webhook(self).await?;
-
-        // Avoid leaking the token to people who receive the event
-        let mut webhook = self.clone();
-        webhook.token = None;
-
-        EventV1::WebhookCreate(webhook.into())
-            .p(self.channel_id.clone())
-            .await;
-
-        Ok(())
-    }
-
-    pub fn assert_token(&self, token: &str) -> Result<()> {
-        if self.token.as_deref() == Some(token) {
-            Ok(())
-        } else {
-            Err(create_error!(InvalidCredentials))
-        }
-    }
-
-    pub async fn update(
-        &mut self,
-        db: &Database,
-        mut partial: PartialWebhook,
-        remove: Vec<FieldsWebhook>,
-    ) -> Result<()> {
-        for field in &remove {
-            self.remove_field(field)
-        }
-
-        self.apply_options(partial.clone());
-
-        db.update_webhook(&self.id, &partial, &remove).await?;
-
-        partial.token = None; // Avoid leaking the token to people who receive the event
-
-        EventV1::WebhookUpdate {
-            id: self.id.clone(),
-            data: partial.into(),
-            remove: remove.into_iter().map(|v| v.into()).collect(),
-        }
-        .p(self.channel_id.clone())
-        .await;
-
-        Ok(())
-    }
-
-    pub fn remove_field(&mut self, field: &FieldsWebhook) {
-        match field {
-            FieldsWebhook::Avatar => self.avatar = None,
-        }
-    }
-
-    pub async fn delete(&self, db: &Database) -> Result<()> {
-        db.delete_webhook(&self.id).await?;
-
-        EventV1::WebhookDelete {
-            id: self.id.clone(),
-        }
-        .p(self.channel_id.clone())
-        .await;
-
-        Ok(())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::{FieldsWebhook, PartialWebhook, Webhook};
-
-    #[async_std::test]
-    async fn crud() {
-        database_test!(|db| async move {
-            let webhook_id = "webhook";
-            let channel_id = "channel";
-
-            let webhook = Webhook {
-                id: webhook_id.to_string(),
-                name: "Webhook Name".to_string(),
-                channel_id: channel_id.to_string(),
-                avatar: None,
-                ..Default::default()
-            };
-
-            db.insert_webhook(&webhook).await.unwrap();
-
-            let mut updated_webhook = webhook.clone();
-            updated_webhook
-                .update(
-                    &db,
-                    PartialWebhook {
-                        name: Some("New Name".to_string()),
-                        ..Default::default()
-                    },
-                    vec![FieldsWebhook::Avatar],
-                )
-                .await
-                .unwrap();
-
-            let fetched_webhook = db.fetch_webhook(webhook_id).await.unwrap();
-            let fetched_webhooks = db.fetch_webhooks_for_channel(channel_id).await.unwrap();
-
-            assert_eq!(updated_webhook, fetched_webhook);
-            assert_ne!(webhook, fetched_webhook);
-            assert_eq!(1, fetched_webhooks.len());
-            assert_eq!(fetched_webhook, fetched_webhooks[0]);
-
-            webhook.delete(&db).await.unwrap();
-            assert!(db.fetch_webhook(webhook_id).await.is_err());
-            assert_eq!(
-                0,
-                db.fetch_webhooks_for_channel(channel_id)
-                    .await
-                    .unwrap()
-                    .len()
-            )
-        });
-    }
-}

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

@@ -1,29 +0,0 @@
-use revolt_result::Result;
-
-use crate::{FieldsWebhook, PartialWebhook, Webhook};
-
-mod mongodb;
-mod reference;
-
-#[async_trait]
-pub trait AbstractWebhooks: Sync + Send {
-    /// Insert new webhook into the database
-    async fn insert_webhook(&self, webhook: &Webhook) -> Result<()>;
-
-    /// Fetch webhook by id
-    async fn fetch_webhook(&self, webhook_id: &str) -> Result<Webhook>;
-
-    /// Fetch webhooks for channel
-    async fn fetch_webhooks_for_channel(&self, channel_id: &str) -> Result<Vec<Webhook>>;
-
-    /// Update webhook with new information
-    async fn update_webhook(
-        &self,
-        webhook_id: &str,
-        partial: &PartialWebhook,
-        remove: &[FieldsWebhook],
-    ) -> Result<()>;
-
-    /// Delete webhook by id
-    async fn delete_webhook(&self, webhook_id: &str) -> Result<()>;
-}

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

@@ -1,77 +0,0 @@
-use futures::StreamExt;
-use revolt_result::Result;
-
-use crate::{FieldsWebhook, PartialWebhook, Webhook};
-use crate::{IntoDocumentPath, MongoDb};
-
-use super::AbstractWebhooks;
-
-static COL: &str = "channel_webhooks";
-
-#[async_trait]
-impl AbstractWebhooks for MongoDb {
-    /// Insert new webhook into the database
-    async fn insert_webhook(&self, webhook: &Webhook) -> Result<()> {
-        query!(self, insert_one, COL, &webhook).map(|_| ())
-    }
-
-    /// Fetch webhook by id
-    async fn fetch_webhook(&self, webhook_id: &str) -> Result<Webhook> {
-        query!(self, find_one_by_id, COL, webhook_id)?.ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch webhooks for channel
-    async fn fetch_webhooks_for_channel(&self, channel_id: &str) -> Result<Vec<Webhook>> {
-        Ok(self
-            .col::<Webhook>(COL)
-            .find(
-                doc! {
-                    "channel_id": channel_id,
-                },
-                None,
-            )
-            .await
-            .map_err(|_| create_database_error!("find", COL))?
-            .filter_map(|s| async {
-                if cfg!(debug_assertions) {
-                    Some(s.unwrap())
-                } else {
-                    s.ok()
-                }
-            })
-            .collect()
-            .await)
-    }
-
-    /// Update webhook with new information
-    async fn update_webhook(
-        &self,
-        webhook_id: &str,
-        partial: &PartialWebhook,
-        remove: &[FieldsWebhook],
-    ) -> Result<()> {
-        query!(
-            self,
-            update_one_by_id,
-            COL,
-            webhook_id,
-            partial,
-            remove.iter().map(|x| x as &dyn IntoDocumentPath).collect(),
-            None
-        )
-        .map(|_| ())
-    }
-
-    /// Delete webhook by id
-    async fn delete_webhook(&self, webhook_id: &str) -> Result<()> {
-        query!(self, delete_one_by_id, COL, webhook_id).map(|_| ())
-    }
-}
-
-impl IntoDocumentPath for FieldsWebhook {
-    fn as_path(&self) -> Option<&'static str> {
-        Some(match self {
-            FieldsWebhook::Avatar => "avatar",
-        })
-    }
-}

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

@@ -1,70 +0,0 @@
-use revolt_result::Result;
-
-use crate::ReferenceDb;
-use crate::{FieldsWebhook, PartialWebhook, Webhook};
-
-use super::AbstractWebhooks;
-
-#[async_trait]
-impl AbstractWebhooks for ReferenceDb {
-    /// Insert new webhook into the database
-    async fn insert_webhook(&self, webhook: &Webhook) -> Result<()> {
-        let mut webhooks = self.channel_webhooks.lock().await;
-        if webhooks.contains_key(&webhook.id) {
-            Err(create_database_error!("insert", "webhook"))
-        } else {
-            webhooks.insert(webhook.id.to_string(), webhook.clone());
-            Ok(())
-        }
-    }
-
-    /// Fetch webhook by id
-    async fn fetch_webhook(&self, webhook_id: &str) -> Result<Webhook> {
-        let webhooks = self.channel_webhooks.lock().await;
-        webhooks
-            .get(webhook_id)
-            .cloned()
-            .ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch webhooks for channel
-    async fn fetch_webhooks_for_channel(&self, channel_id: &str) -> Result<Vec<Webhook>> {
-        let webhooks = self.channel_webhooks.lock().await;
-        Ok(webhooks
-            .values()
-            .filter(|webhook| webhook.channel_id == channel_id)
-            .cloned()
-            .collect())
-    }
-
-    /// Update webhook with new information
-    async fn update_webhook(
-        &self,
-        webhook_id: &str,
-        partial: &PartialWebhook,
-        remove: &[FieldsWebhook],
-    ) -> Result<()> {
-        let mut webhooks = self.channel_webhooks.lock().await;
-        if let Some(webhook) = webhooks.get_mut(webhook_id) {
-            for field in remove {
-                #[allow(clippy::disallowed_methods)]
-                webhook.remove_field(field);
-            }
-
-            webhook.apply_options(partial.clone());
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Delete webhook by id
-    async fn delete_webhook(&self, webhook_id: &str) -> Result<()> {
-        let mut webhooks = self.channel_webhooks.lock().await;
-        if webhooks.remove(webhook_id).is_some() {
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-}

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

@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;

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

@@ -1,818 +0,0 @@
-use std::collections::HashMap;
-
-use revolt_config::config;
-use revolt_models::v0::{self, MessageAuthor};
-use revolt_permissions::OverrideField;
-use revolt_result::Result;
-use serde::{Deserialize, Serialize};
-use ulid::Ulid;
-
-use crate::{
-    events::client::EventV1, tasks::ack::AckEvent, Database, File, IntoDocumentPath, PartialServer,
-    Server, SystemMessage, User,
-};
-
-auto_derived!(
-    #[serde(tag = "channel_type")]
-    pub enum Channel {
-        /// Personal "Saved Notes" channel which allows users to save messages
-        SavedMessages {
-            /// Unique Id
-            #[serde(rename = "_id")]
-            id: String,
-            /// Id of the user this channel belongs to
-            user: String,
-        },
-        /// Direct message channel between two users
-        DirectMessage {
-            /// Unique Id
-            #[serde(rename = "_id")]
-            id: String,
-
-            /// Whether this direct message channel is currently open on both sides
-            active: bool,
-            /// 2-tuple of user ids participating in direct message
-            recipients: Vec<String>,
-            /// Id of the last message sent in this channel
-            #[serde(skip_serializing_if = "Option::is_none")]
-            last_message_id: Option<String>,
-        },
-        /// Group channel between 1 or more participants
-        Group {
-            /// Unique Id
-            #[serde(rename = "_id")]
-            id: String,
-
-            /// Display name of the channel
-            name: String,
-            /// User id of the owner of the group
-            owner: String,
-            /// Channel description
-            #[serde(skip_serializing_if = "Option::is_none")]
-            description: Option<String>,
-            /// Array of user ids participating in channel
-            recipients: Vec<String>,
-
-            /// Custom icon attachment
-            #[serde(skip_serializing_if = "Option::is_none")]
-            icon: Option<File>,
-            /// Id of the last message sent in this channel
-            #[serde(skip_serializing_if = "Option::is_none")]
-            last_message_id: Option<String>,
-
-            /// Permissions assigned to members of this group
-            /// (does not apply to the owner of the group)
-            #[serde(skip_serializing_if = "Option::is_none")]
-            permissions: Option<i64>,
-
-            /// Whether this group is marked as not safe for work
-            #[serde(skip_serializing_if = "crate::if_false", default)]
-            nsfw: bool,
-        },
-        /// Text channel belonging to a server
-        TextChannel {
-            /// Unique Id
-            #[serde(rename = "_id")]
-            id: String,
-            /// Id of the server this channel belongs to
-            server: String,
-
-            /// Display name of the channel
-            name: String,
-            /// Channel description
-            #[serde(skip_serializing_if = "Option::is_none")]
-            description: Option<String>,
-
-            /// Custom icon attachment
-            #[serde(skip_serializing_if = "Option::is_none")]
-            icon: Option<File>,
-            /// Id of the last message sent in this channel
-            #[serde(skip_serializing_if = "Option::is_none")]
-            last_message_id: Option<String>,
-
-            /// Default permissions assigned to users in this channel
-            #[serde(skip_serializing_if = "Option::is_none")]
-            default_permissions: Option<OverrideField>,
-            /// Permissions assigned based on role to this channel
-            #[serde(
-                default = "HashMap::<String, OverrideField>::new",
-                skip_serializing_if = "HashMap::<String, OverrideField>::is_empty"
-            )]
-            role_permissions: HashMap<String, OverrideField>,
-
-            /// Whether this channel is marked as not safe for work
-            #[serde(skip_serializing_if = "crate::if_false", default)]
-            nsfw: bool,
-        },
-        /// Voice channel belonging to a server
-        VoiceChannel {
-            /// Unique Id
-            #[serde(rename = "_id")]
-            id: String,
-            /// Id of the server this channel belongs to
-            server: String,
-
-            /// Display name of the channel
-            name: String,
-            #[serde(skip_serializing_if = "Option::is_none")]
-            /// Channel description
-            description: Option<String>,
-            /// Custom icon attachment
-            #[serde(skip_serializing_if = "Option::is_none")]
-            icon: Option<File>,
-
-            /// Default permissions assigned to users in this channel
-            #[serde(skip_serializing_if = "Option::is_none")]
-            default_permissions: Option<OverrideField>,
-            /// Permissions assigned based on role to this channel
-            #[serde(
-                default = "HashMap::<String, OverrideField>::new",
-                skip_serializing_if = "HashMap::<String, OverrideField>::is_empty"
-            )]
-            role_permissions: HashMap<String, OverrideField>,
-
-            /// Whether this channel is marked as not safe for work
-            #[serde(skip_serializing_if = "crate::if_false", default)]
-            nsfw: bool,
-        },
-    }
-);
-
-auto_derived!(
-    #[derive(Default)]
-    pub struct PartialChannel {
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub name: Option<String>,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub owner: Option<String>,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub description: Option<String>,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub icon: Option<File>,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub nsfw: Option<bool>,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub active: Option<bool>,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub permissions: Option<i64>,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub role_permissions: Option<HashMap<String, OverrideField>>,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub default_permissions: Option<OverrideField>,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub last_message_id: Option<String>,
-    }
-
-    /// Optional fields on channel object
-    pub enum FieldsChannel {
-        Description,
-        Icon,
-        DefaultPermissions,
-    }
-);
-
-#[allow(clippy::disallowed_methods)]
-impl Channel {
-    /* /// Create a channel
-    pub async fn create(&self, db: &Database) -> Result<()> {
-        db.insert_channel(self).await?;
-
-        let event = EventV1::ChannelCreate(self.clone().into());
-        match self {
-            Self::SavedMessages { user, .. } => event.private(user.clone()).await,
-            Self::DirectMessage { recipients, .. } | Self::Group { recipients, .. } => {
-                for recipient in recipients {
-                    event.clone().private(recipient.clone()).await;
-                }
-            }
-            Self::TextChannel { server, .. } | Self::VoiceChannel { server, .. } => {
-                event.p(server.clone()).await;
-            }
-        }
-
-        Ok(())
-    }*/
-
-    /// Create a new server channel
-    pub async fn create_server_channel(
-        db: &Database,
-        server: &mut Server,
-        data: v0::DataCreateServerChannel,
-        update_server: bool,
-    ) -> Result<Channel> {
-        let config = config().await;
-        if server.channels.len() > config.features.limits.default.server_channels {
-            return Err(create_error!(TooManyChannels {
-                max: config.features.limits.default.server_channels,
-            }));
-        };
-
-        let id = ulid::Ulid::new().to_string();
-        let channel = match data.channel_type {
-            v0::LegacyServerChannelType::Text => Channel::TextChannel {
-                id: id.clone(),
-                server: server.id.to_owned(),
-                name: data.name,
-                description: data.description,
-                icon: None,
-                last_message_id: None,
-                default_permissions: None,
-                role_permissions: HashMap::new(),
-                nsfw: data.nsfw.unwrap_or(false),
-            },
-            v0::LegacyServerChannelType::Voice => Channel::VoiceChannel {
-                id: id.clone(),
-                server: server.id.to_owned(),
-                name: data.name,
-                description: data.description,
-                icon: None,
-                default_permissions: None,
-                role_permissions: HashMap::new(),
-                nsfw: data.nsfw.unwrap_or(false),
-            },
-        };
-
-        db.insert_channel(&channel).await?;
-
-        if update_server {
-            server
-                .update(
-                    db,
-                    PartialServer {
-                        channels: Some([server.channels.clone(), [id].into()].concat()),
-                        ..Default::default()
-                    },
-                    vec![],
-                )
-                .await?;
-
-            EventV1::ChannelCreate(channel.clone().into())
-                .p(server.id.clone())
-                .await;
-        }
-
-        Ok(channel)
-    }
-
-    /// Create a group
-    pub async fn create_group(
-        db: &Database,
-        mut data: v0::DataCreateGroup,
-        owner_id: String,
-    ) -> Result<Channel> {
-        data.users.insert(owner_id.to_string());
-
-        let config = config().await;
-        if data.users.len() > config.features.limits.default.group_size {
-            return Err(create_error!(GroupTooLarge {
-                max: config.features.limits.default.group_size,
-            }));
-        }
-
-        let recipients = data.users.into_iter().collect::<Vec<String>>();
-        let channel = Channel::Group {
-            id: ulid::Ulid::new().to_string(),
-
-            name: data.name,
-            owner: owner_id,
-            description: data.description,
-            recipients: recipients.clone(),
-
-            icon: None,
-            last_message_id: None,
-
-            permissions: None,
-
-            nsfw: data.nsfw.unwrap_or(false),
-        };
-
-        db.insert_channel(&channel).await?;
-
-        let event = EventV1::ChannelCreate(channel.clone().into());
-        for recipient in recipients {
-            event.clone().private(recipient).await;
-        }
-
-        Ok(channel)
-    }
-
-    /// Create a DM (or return the existing one / saved messages)
-    pub async fn create_dm(db: &Database, user_a: &User, user_b: &User) -> Result<Channel> {
-        // Try to find existing channel
-        if let Ok(channel) = db.find_direct_message_channel(&user_a.id, &user_b.id).await {
-            Ok(channel)
-        } else {
-            let channel = if user_a.id == user_b.id {
-                // Create a new saved messages channel
-                Channel::SavedMessages {
-                    id: Ulid::new().to_string(),
-                    user: user_a.id.to_string(),
-                }
-            } else {
-                // Create a new DM channel
-                Channel::DirectMessage {
-                    id: Ulid::new().to_string(),
-                    active: true, // show by default
-                    recipients: vec![user_a.id.clone(), user_b.id.clone()],
-                    last_message_id: None,
-                }
-            };
-
-            db.insert_channel(&channel).await?;
-
-            match &channel {
-                Channel::DirectMessage { .. } => {
-                    let event = EventV1::ChannelCreate(channel.clone().into());
-                    event.clone().private(user_a.id.clone()).await;
-                    event.private(user_b.id.clone()).await;
-                }
-                _ => {}
-            };
-
-            Ok(channel)
-        }
-    }
-
-    /// Add user to a group
-    pub async fn add_user_to_group(
-        &mut self,
-        db: &Database,
-        user: &User,
-        by_id: &str,
-    ) -> Result<()> {
-        if let Channel::Group { recipients, .. } = self {
-            if recipients.contains(&String::from(&user.id)) {
-                return Err(create_error!(AlreadyInGroup));
-            }
-
-            let config = config().await;
-            if recipients.len() >= config.features.limits.default.group_size {
-                return Err(create_error!(GroupTooLarge {
-                    max: config.features.limits.default.group_size
-                }));
-            }
-
-            recipients.push(String::from(&user.id));
-        }
-
-        match &self {
-            Channel::Group { id, .. } => {
-                db.add_user_to_group(id, &user.id).await?;
-
-                EventV1::ChannelGroupJoin {
-                    id: id.to_string(),
-                    user: user.id.to_string(),
-                }
-                .p(id.to_string())
-                .await;
-
-                SystemMessage::UserAdded {
-                    id: user.id.to_string(),
-                    by: by_id.to_string(),
-                }
-                .into_message(id.to_string())
-                .send(
-                    db,
-                    MessageAuthor::System {
-                        username: &user.username,
-                        avatar: user.avatar.as_ref().map(|file| file.id.as_ref()),
-                    },
-                    self,
-                    false,
-                )
-                .await
-                .ok();
-
-                EventV1::ChannelCreate(self.clone().into())
-                    .private(user.id.to_string())
-                    .await;
-
-                Ok(())
-            }
-            _ => Err(create_error!(InvalidOperation)),
-        }
-    }
-
-    /// Map out whether it is a direct DM
-    pub fn is_direct_dm(&self) -> bool {
-        matches!(self, Channel::DirectMessage { .. })
-    }
-
-    /// Check whether has a user as a recipient
-    pub fn contains_user(&self, user_id: &str) -> bool {
-        match self {
-            Channel::Group { recipients, .. } => recipients.contains(&String::from(user_id)),
-            _ => false,
-        }
-    }
-
-    /// Get list of recipients
-    pub fn users(&self) -> Result<Vec<String>> {
-        match self {
-            Channel::Group { recipients, .. } => Ok(recipients.to_owned()),
-            _ => Err(create_error!(NotFound)),
-        }
-    }
-
-    /// Clone this channel's id
-    pub fn id(&self) -> String {
-        match self {
-            Channel::DirectMessage { id, .. }
-            | Channel::Group { id, .. }
-            | Channel::SavedMessages { id, .. }
-            | Channel::TextChannel { id, .. }
-            | Channel::VoiceChannel { id, .. } => id.clone(),
-        }
-    }
-
-    /// Set role permission on a channel
-    pub async fn set_role_permission(
-        &mut self,
-        db: &Database,
-        role_id: &str,
-        permissions: OverrideField,
-    ) -> Result<()> {
-        match self {
-            Channel::TextChannel {
-                id,
-                server,
-                role_permissions,
-                ..
-            }
-            | Channel::VoiceChannel {
-                id,
-                server,
-                role_permissions,
-                ..
-            } => {
-                db.set_channel_role_permission(id, role_id, permissions)
-                    .await?;
-
-                role_permissions.insert(role_id.to_string(), permissions);
-
-                EventV1::ChannelUpdate {
-                    id: id.clone(),
-                    data: PartialChannel {
-                        role_permissions: Some(role_permissions.clone()),
-                        ..Default::default()
-                    }
-                    .into(),
-                    clear: vec![],
-                }
-                .p(server.clone())
-                .await;
-
-                Ok(())
-            }
-            _ => Err(create_error!(InvalidOperation)),
-        }
-    }
-
-    /// Update channel data
-    pub async fn update(
-        &mut self,
-        db: &Database,
-        partial: PartialChannel,
-        remove: Vec<FieldsChannel>,
-    ) -> Result<()> {
-        for field in &remove {
-            self.remove_field(field);
-        }
-
-        self.apply_options(partial.clone());
-
-        let id = self.id().to_string();
-        db.update_channel(&id, &partial, remove.clone()).await?;
-
-        EventV1::ChannelUpdate {
-            id: id.clone(),
-            data: partial.into(),
-            clear: remove.into_iter().map(|v| v.into()).collect(),
-        }
-        .p(match self {
-            Self::TextChannel { server, .. } | Self::VoiceChannel { server, .. } => server.clone(),
-            _ => id,
-        })
-        .await;
-
-        Ok(())
-    }
-
-    /// Remove a field from Channel object
-    pub fn remove_field(&mut self, field: &FieldsChannel) {
-        match field {
-            FieldsChannel::Description => match self {
-                Self::Group { description, .. }
-                | Self::TextChannel { description, .. }
-                | Self::VoiceChannel { description, .. } => {
-                    description.take();
-                }
-                _ => {}
-            },
-            FieldsChannel::Icon => match self {
-                Self::Group { icon, .. }
-                | Self::TextChannel { icon, .. }
-                | Self::VoiceChannel { icon, .. } => {
-                    icon.take();
-                }
-                _ => {}
-            },
-            FieldsChannel::DefaultPermissions => match self {
-                Self::TextChannel {
-                    default_permissions,
-                    ..
-                }
-                | Self::VoiceChannel {
-                    default_permissions,
-                    ..
-                } => {
-                    default_permissions.take();
-                }
-                _ => {}
-            },
-        }
-    }
-
-    /// Remove multiple fields from Channel object
-    pub fn remove_fields(&mut self, partial: Vec<FieldsChannel>) {
-        for field in partial {
-            self.remove_field(&field)
-        }
-    }
-
-    /// Apply partial channel to channel
-    pub fn apply_options(&mut self, partial: PartialChannel) {
-        match self {
-            Self::SavedMessages { .. } => {}
-            Self::DirectMessage { active, .. } => {
-                if let Some(v) = partial.active {
-                    *active = v;
-                }
-            }
-            Self::Group {
-                name,
-                owner,
-                description,
-                icon,
-                nsfw,
-                permissions,
-                ..
-            } => {
-                if let Some(v) = partial.name {
-                    *name = v;
-                }
-
-                if let Some(v) = partial.owner {
-                    *owner = v;
-                }
-
-                if let Some(v) = partial.description {
-                    description.replace(v);
-                }
-
-                if let Some(v) = partial.icon {
-                    icon.replace(v);
-                }
-
-                if let Some(v) = partial.nsfw {
-                    *nsfw = v;
-                }
-
-                if let Some(v) = partial.permissions {
-                    permissions.replace(v);
-                }
-            }
-            Self::TextChannel {
-                name,
-                description,
-                icon,
-                nsfw,
-                default_permissions,
-                role_permissions,
-                ..
-            }
-            | Self::VoiceChannel {
-                name,
-                description,
-                icon,
-                nsfw,
-                default_permissions,
-                role_permissions,
-                ..
-            } => {
-                if let Some(v) = partial.name {
-                    *name = v;
-                }
-
-                if let Some(v) = partial.description {
-                    description.replace(v);
-                }
-
-                if let Some(v) = partial.icon {
-                    icon.replace(v);
-                }
-
-                if let Some(v) = partial.nsfw {
-                    *nsfw = v;
-                }
-
-                if let Some(v) = partial.role_permissions {
-                    *role_permissions = v;
-                }
-
-                if let Some(v) = partial.default_permissions {
-                    default_permissions.replace(v);
-                }
-            }
-        }
-    }
-
-    /// Acknowledge a message
-    pub async fn ack(&self, user: &str, message: &str) -> Result<()> {
-        EventV1::ChannelAck {
-            id: self.id().to_string(),
-            user: user.to_string(),
-            message_id: message.to_string(),
-        }
-        .private(user.to_string())
-        .await;
-
-        crate::tasks::ack::queue(
-            self.id().to_string(),
-            user.to_string(),
-            AckEvent::AckMessage {
-                id: message.to_string(),
-            },
-        )
-        .await;
-
-        Ok(())
-    }
-
-    /// Remove user from a group
-    pub async fn remove_user_from_group(
-        &self,
-        db: &Database,
-        user: &User,
-        by_id: Option<&str>,
-        silent: bool,
-    ) -> Result<()> {
-        match &self {
-            Channel::Group {
-                id,
-                name,
-                owner,
-                recipients,
-                ..
-            } => {
-                if &user.id == owner {
-                    if let Some(new_owner) = recipients.iter().find(|x| *x != &user.id) {
-                        db.update_channel(
-                            id,
-                            &PartialChannel {
-                                owner: Some(new_owner.into()),
-                                ..Default::default()
-                            },
-                            vec![],
-                        )
-                        .await?;
-
-                        SystemMessage::ChannelOwnershipChanged {
-                            from: owner.to_string(),
-                            to: new_owner.to_string(),
-                        }
-                        .into_message(id.to_string())
-                        .send(
-                            db,
-                            MessageAuthor::System {
-                                username: name,
-                                avatar: None,
-                            },
-                            self,
-                            false,
-                        )
-                        .await
-                        .ok();
-                    } else {
-                        return self.delete(db).await;
-                    }
-                }
-
-                EventV1::ChannelGroupLeave {
-                    id: id.to_string(),
-                    user: user.id.to_string(),
-                }
-                .p(id.to_string())
-                .await;
-
-                if !silent {
-                    if let Some(by) = by_id {
-                        SystemMessage::UserRemove {
-                            id: user.id.to_string(),
-                            by: by.to_string(),
-                        }
-                    } else {
-                        SystemMessage::UserLeft {
-                            id: user.id.to_string(),
-                        }
-                    }
-                    .into_message(id.to_string())
-                    .send(
-                        db,
-                        MessageAuthor::System {
-                            username: &user.username,
-                            avatar: user.avatar.as_ref().map(|file| file.id.as_ref()),
-                        },
-                        self,
-                        false,
-                    )
-                    .await
-                    .ok();
-                }
-
-                Ok(())
-            }
-
-            _ => Err(create_error!(InvalidOperation)),
-        }
-    }
-
-    /// Delete a channel
-    pub async fn delete(&self, db: &Database) -> Result<()> {
-        let id = self.id().to_string();
-        EventV1::ChannelDelete { id: id.clone() }.p(id).await;
-        // TODO: missing functionality:
-        // - group invites
-        // - channels list / categories list on server
-        db.delete_channel(self).await
-    }
-}
-
-impl IntoDocumentPath for FieldsChannel {
-    fn as_path(&self) -> Option<&'static str> {
-        Some(match self {
-            FieldsChannel::Description => "description",
-            FieldsChannel::Icon => "icon",
-            FieldsChannel::DefaultPermissions => "default_permissions",
-        })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
-
-    use crate::{fixture, util::permissions::DatabasePermissionQuery};
-
-    #[async_std::test]
-    async fn permissions_group_channel() {
-        database_test!(|db| async move {
-            fixture!(db, "group_with_members",
-                owner user 0
-                member1 user 1
-                member2 user 2
-                channel channel 3);
-
-            let mut query = DatabasePermissionQuery::new(&db, &owner).channel(&channel);
-            assert!(calculate_channel_permissions(&mut query)
-                .await
-                .has_channel_permission(ChannelPermission::SendMessage));
-
-            let mut query = DatabasePermissionQuery::new(&db, &member1).channel(&channel);
-            assert!(calculate_channel_permissions(&mut query)
-                .await
-                .has_channel_permission(ChannelPermission::SendMessage));
-
-            let mut query = DatabasePermissionQuery::new(&db, &member2).channel(&channel);
-            assert!(!calculate_channel_permissions(&mut query)
-                .await
-                .has_channel_permission(ChannelPermission::SendMessage));
-        });
-    }
-
-    #[async_std::test]
-    async fn permissions_text_channel() {
-        database_test!(|db| async move {
-            fixture!(db, "server_with_roles",
-                owner user 0
-                moderator user 1
-                user user 2
-                channel channel 3);
-
-            let mut query = DatabasePermissionQuery::new(&db, &owner).channel(&channel);
-            assert!(calculate_channel_permissions(&mut query)
-                .await
-                .has_channel_permission(ChannelPermission::SendMessage));
-
-            let mut query = DatabasePermissionQuery::new(&db, &moderator).channel(&channel);
-            assert!(calculate_channel_permissions(&mut query)
-                .await
-                .has_channel_permission(ChannelPermission::SendMessage));
-
-            let mut query = DatabasePermissionQuery::new(&db, &user).channel(&channel);
-            assert!(!calculate_channel_permissions(&mut query)
-                .await
-                .has_channel_permission(ChannelPermission::SendMessage));
-        });
-    }
-}

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

@@ -1,50 +0,0 @@
-use crate::{revolt_result::Result, Channel, FieldsChannel, PartialChannel};
-use revolt_permissions::OverrideField;
-mod mongodb;
-mod reference;
-
-#[async_trait]
-pub trait AbstractChannels: Sync + Send {
-    /// Insert a new channel in the database
-    async fn insert_channel(&self, channel: &Channel) -> Result<()>;
-
-    /// Fetch a channel from the database
-    async fn fetch_channel(&self, channel_id: &str) -> Result<Channel>;
-
-    /// Fetch all channels from the database
-    async fn fetch_channels<'a>(&self, ids: &'a [String]) -> Result<Vec<Channel>>;
-
-    /// Fetch all direct messages for a user
-    async fn find_direct_messages(&self, user_id: &str) -> Result<Vec<Channel>>;
-
-    // Fetch saved messages channel
-    async fn find_saved_messages_channel(&self, user_id: &str) -> Result<Channel>;
-
-    // Fetch direct message channel (DM or Saved Messages)
-    async fn find_direct_message_channel(&self, user_a: &str, user_b: &str) -> Result<Channel>;
-
-    /// Insert a user to a group
-    async fn add_user_to_group(&self, channel_id: &str, user_id: &str) -> Result<()>;
-
-    /// Insert channel role permissions
-    async fn set_channel_role_permission(
-        &self,
-        channel_id: &str,
-        role_id: &str,
-        permissions: OverrideField,
-    ) -> Result<()>;
-
-    // Update channel
-    async fn update_channel(
-        &self,
-        id: &str,
-        channel_id: &PartialChannel,
-        remove: Vec<FieldsChannel>,
-    ) -> Result<()>;
-
-    // Remove a user from a group
-    async fn remove_user_from_group(&self, channel_id: &str, user_id: &str) -> Result<()>;
-
-    // Delete a channel
-    async fn delete_channel(&self, channel_id: &Channel) -> Result<()>;
-}

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

@@ -1,157 +0,0 @@
-use std::collections::hash_map::Entry;
-
-use super::AbstractChannels;
-use crate::ReferenceDb;
-use crate::{Channel, FieldsChannel, PartialChannel};
-use revolt_permissions::OverrideField;
-use revolt_result::Result;
-
-#[async_trait]
-impl AbstractChannels for ReferenceDb {
-    /// Insert a new channel in the database
-    async fn insert_channel(&self, channel: &Channel) -> Result<()> {
-        let mut channels = self.channels.lock().await;
-        if let Entry::Vacant(entry) = channels.entry(channel.id()) {
-            entry.insert(channel.clone());
-            Ok(())
-        } else {
-            Err(create_database_error!("insert", "channel"))
-        }
-    }
-
-    /// Fetch a channel from the database
-    async fn fetch_channel(&self, channel_id: &str) -> Result<Channel> {
-        let channels = self.channels.lock().await;
-        channels
-            .get(channel_id)
-            .cloned()
-            .ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch all channels from the database
-    async fn fetch_channels<'a>(&self, ids: &'a [String]) -> Result<Vec<Channel>> {
-        let channels = self.channels.lock().await;
-        ids.iter()
-            .map(|id| {
-                channels
-                    .get(id)
-                    .cloned()
-                    .ok_or_else(|| create_error!(NotFound))
-            })
-            .collect()
-    }
-
-    /// Fetch all direct messages for a user
-    async fn find_direct_messages(&self, user_id: &str) -> Result<Vec<Channel>> {
-        let channels = self.channels.lock().await;
-        Ok(channels
-            .values()
-            .filter(|channel| channel.contains_user(user_id))
-            .cloned()
-            .collect())
-    }
-
-    // Fetch saved messages channel
-    async fn find_saved_messages_channel(&self, user_id: &str) -> Result<Channel> {
-        let channels = self.channels.lock().await;
-        channels
-            .get(user_id)
-            .cloned()
-            .ok_or_else(|| create_database_error!("fetch", "channel"))
-    }
-
-    // Fetch direct message channel (DM or Saved Messages)
-    async fn find_direct_message_channel(&self, user_a: &str, user_b: &str) -> Result<Channel> {
-        let channels = self.channels.lock().await;
-        for (_, data) in channels.iter() {
-            if data.contains_user(user_a) && data.contains_user(user_b) {
-                return Ok(data.to_owned());
-            }
-        }
-        Err(create_error!(NotFound))
-    }
-    /// Insert a user to a group
-    async fn add_user_to_group(&self, channel_id: &str, user_id: &str) -> Result<()> {
-        let mut channels = self.channels.lock().await;
-
-        if let Some(Channel::Group { recipients, .. }) = channels.get_mut(channel_id) {
-            recipients.push(String::from(user_id));
-            Ok(())
-        } else {
-            Err(create_error!(InvalidOperation))
-        }
-    }
-    /// Insert channel role permissions
-    async fn set_channel_role_permission(
-        &self,
-        channel_id: &str,
-        role_id: &str,
-        permissions: OverrideField,
-    ) -> Result<()> {
-        let mut channels = self.channels.lock().await;
-
-        if let Some(mut channel) = channels.get_mut(channel_id) {
-            match &mut channel {
-                Channel::TextChannel {
-                    role_permissions, ..
-                }
-                | Channel::VoiceChannel {
-                    role_permissions, ..
-                } => {
-                    if role_permissions.get(role_id).is_some() {
-                        role_permissions.remove(role_id);
-                        role_permissions.insert(String::from(role_id), permissions);
-
-                        Ok(())
-                    } else {
-                        Err(create_error!(NotFound))
-                    }
-                }
-                _ => Err(create_error!(NotFound)),
-            }
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    // Update channel
-    async fn update_channel(
-        &self,
-        id: &str,
-        channel: &PartialChannel,
-        remove: Vec<FieldsChannel>,
-    ) -> Result<()> {
-        let mut channels = self.channels.lock().await;
-        if let Some(channel_data) = channels.get_mut(id) {
-            channel_data.apply_options(channel.to_owned());
-            channel_data.remove_fields(remove);
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    // Remove a user from a group
-    async fn remove_user_from_group(&self, channel: &str, user: &str) -> Result<()> {
-        let mut channels = self.channels.lock().await;
-        if let Some(channel_data) = channels.get_mut(channel) {
-            if channel_data.users()?.contains(&String::from(user)) {
-                channel_data.users()?.retain(|x| x != user);
-                return Ok(());
-            } else {
-                return Err(create_error!(NotFound));
-            }
-        }
-        Err(create_error!(NotFound))
-    }
-
-    // Delete a channel
-    async fn delete_channel(&self, channel: &Channel) -> Result<()> {
-        let mut channels = self.channels.lock().await;
-        if channels.remove(&channel.id()).is_some() {
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-}

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

@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;

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

@@ -1,67 +0,0 @@
-use revolt_result::Result;
-
-use crate::Emoji;
-use crate::EmojiParent;
-use crate::ReferenceDb;
-
-use super::AbstractEmojis;
-
-#[async_trait]
-impl AbstractEmojis for ReferenceDb {
-    /// Insert emoji into database.
-    async fn insert_emoji(&self, emoji: &Emoji) -> Result<()> {
-        let mut emojis = self.emojis.lock().await;
-        if emojis.contains_key(&emoji.id) {
-            Err(create_database_error!("insert", "emoji"))
-        } else {
-            emojis.insert(emoji.id.to_string(), emoji.clone());
-            Ok(())
-        }
-    }
-
-    /// Fetch an emoji by its id
-    async fn fetch_emoji(&self, id: &str) -> Result<Emoji> {
-        let emojis = self.emojis.lock().await;
-        emojis
-            .get(id)
-            .cloned()
-            .ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch emoji by their parent id
-    async fn fetch_emoji_by_parent_id(&self, parent_id: &str) -> Result<Vec<Emoji>> {
-        let emojis = self.emojis.lock().await;
-        Ok(emojis
-            .values()
-            .filter(|emoji| match &emoji.parent {
-                EmojiParent::Server { id } => id == parent_id,
-                _ => false,
-            })
-            .cloned()
-            .collect())
-    }
-
-    /// Fetch emoji by their parent ids
-    async fn fetch_emoji_by_parent_ids(&self, parent_ids: &[String]) -> Result<Vec<Emoji>> {
-        let emojis = self.emojis.lock().await;
-        Ok(emojis
-            .values()
-            .filter(|emoji| match &emoji.parent {
-                EmojiParent::Server { id } => parent_ids.contains(id),
-                _ => false,
-            })
-            .cloned()
-            .collect())
-    }
-
-    /// Detach an emoji by its id
-    async fn detach_emoji(&self, emoji: &Emoji) -> Result<()> {
-        let mut emojis = self.emojis.lock().await;
-        if let Some(bot) = emojis.get_mut(&emoji.id) {
-            bot.parent = EmojiParent::Detached;
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-}

crates/core/database/src/models/files/mod.rs

@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;

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

@@ -1,107 +0,0 @@
-use crate::Database;
-
-use revolt_result::Result;
-
-auto_derived_partial!(
-    /// File
-    pub struct File {
-        /// Unique Id
-        #[serde(rename = "_id")]
-        pub id: String,
-        /// Tag / bucket this file was uploaded to
-        pub tag: String,
-        /// Original filename
-        pub filename: String,
-        /// Parsed metadata of this file
-        pub metadata: Metadata,
-        /// Raw content type of this file
-        pub content_type: String,
-        /// Size of this file (in bytes)
-        pub size: isize,
-
-        /// Whether this file was deleted
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub deleted: Option<bool>,
-        /// Whether this file was reported
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub reported: Option<bool>,
-
-        // TODO: migrate this mess to having:
-        // - author_id
-        // - parent: Parent { Message(id), User(id), etc }
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub message_id: Option<String>,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub user_id: Option<String>,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub server_id: Option<String>,
-
-        /// Id of the object this file is associated with
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub object_id: Option<String>,
-    },
-    "PartialFile"
-);
-
-auto_derived!(
-    /// Metadata associated with a file
-    #[serde(tag = "type")]
-    #[derive(Default)]
-    pub enum Metadata {
-        /// File is just a generic uncategorised file
-        #[default]
-        File,
-        /// File contains textual data and should be displayed as such
-        Text,
-        /// File is an image with specific dimensions
-        Image { width: isize, height: isize },
-        /// File is a video with specific dimensions
-        Video { width: isize, height: isize },
-        /// File is audio
-        Audio,
-    }
-);
-
-impl File {
-    /// Use a file for a message attachment
-    pub async fn use_attachment(db: &Database, id: &str, parent: &str) -> Result<File> {
-        db.find_and_use_attachment(id, "attachments", "message", parent)
-            .await
-    }
-
-    /// Use a file for a user profile background
-    pub async fn use_background(db: &Database, id: &str, parent: &str) -> Result<File> {
-        db.find_and_use_attachment(id, "backgrounds", "user", parent)
-            .await
-    }
-
-    /// Use a file for a user avatar
-    pub async fn use_avatar(db: &Database, id: &str, parent: &str) -> Result<File> {
-        db.find_and_use_attachment(id, "avatars", "user", parent)
-            .await
-    }
-
-    /// Use a file for an icon
-    pub async fn use_icon(db: &Database, id: &str, parent: &str) -> Result<File> {
-        db.find_and_use_attachment(id, "icons", "object", parent)
-            .await
-    }
-
-    /// Use a file for a server icon
-    pub async fn use_server_icon(db: &Database, id: &str, parent: &str) -> Result<File> {
-        db.find_and_use_attachment(id, "icons", "object", parent)
-            .await
-    }
-
-    /// Use a file for a server banner
-    pub async fn use_banner(db: &Database, id: &str, parent: &str) -> Result<File> {
-        db.find_and_use_attachment(id, "banners", "server", parent)
-            .await
-    }
-
-    /// Use a file for an emoji
-    pub async fn use_emoji(db: &Database, id: &str, parent: &str) -> Result<File> {
-        db.find_and_use_attachment(id, "emojis", "object", parent)
-            .await
-    }
-}

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

@@ -1,89 +0,0 @@
-use revolt_result::Result;
-
-use crate::File;
-use crate::ReferenceDb;
-
-use super::AbstractAttachments;
-
-#[async_trait]
-impl AbstractAttachments for ReferenceDb {
-    /// Insert attachment into database.
-    async fn insert_attachment(&self, attachment: &File) -> Result<()> {
-        let mut attachments = self.files.lock().await;
-        if attachments.contains_key(&attachment.id) {
-            Err(create_database_error!("insert", "attachment"))
-        } else {
-            attachments.insert(attachment.id.to_string(), attachment.clone());
-            Ok(())
-        }
-    }
-
-    /// Find an attachment by its details and mark it as used by a given parent.
-    async fn find_and_use_attachment(
-        &self,
-        id: &str,
-        tag: &str,
-        parent_type: &str,
-        parent_id: &str,
-    ) -> Result<File> {
-        let mut files = self.files.lock().await;
-        if let Some(file) = files.get_mut(id) {
-            if file.tag == tag {
-                match parent_type {
-                    "message" => file.message_id = Some(parent_id.to_owned()),
-                    "user" => file.user_id = Some(parent_id.to_owned()),
-                    "object" => file.object_id = Some(parent_id.to_owned()),
-                    "server" => file.server_id = Some(parent_id.to_owned()),
-                    _ => unreachable!(),
-                }
-
-                Ok(file.clone())
-            } else {
-                Err(create_error!(NotFound))
-            }
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Mark an attachment as having been reported.
-    async fn mark_attachment_as_reported(&self, id: &str) -> Result<()> {
-        let mut files = self.files.lock().await;
-        if let Some(file) = files.get_mut(id) {
-            file.reported = Some(true);
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Mark an attachment as having been deleted.
-    async fn mark_attachment_as_deleted(&self, id: &str) -> Result<()> {
-        let mut files = self.files.lock().await;
-        if let Some(file) = files.get_mut(id) {
-            file.deleted = Some(true);
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Mark multiple attachments as having been deleted.
-    async fn mark_attachments_as_deleted(&self, ids: &[String]) -> Result<()> {
-        let mut files = self.files.lock().await;
-
-        for id in ids {
-            if !files.contains_key(id) {
-                return Err(create_error!(NotFound));
-            }
-        }
-
-        for id in ids {
-            if let Some(file) = files.get_mut(id) {
-                file.reported = Some(true);
-            }
-        }
-
-        Ok(())
-    }
-}

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

@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;

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

@@ -1,787 +0,0 @@
-use std::collections::HashSet;
-
-use indexmap::{IndexMap, IndexSet};
-use iso8601_timestamp::Timestamp;
-use revolt_config::config;
-use revolt_models::v0::{
-    self, BulkMessageResponse, DataMessageSend, Embed, MessageAuthor, MessageSort, MessageWebhook,
-    PushNotification, ReplyIntent, SendableEmbed, Text, RE_MENTION,
-};
-use revolt_permissions::{ChannelPermission, PermissionValue};
-use revolt_result::Result;
-use ulid::Ulid;
-use validator::Validate;
-
-use crate::{
-    events::client::EventV1,
-    tasks::{self, ack::AckEvent},
-    util::idempotency::IdempotencyKey,
-    Channel, Database, Emoji, File, User,
-};
-
-auto_derived_partial!(
-    /// Message
-    pub struct Message {
-        /// Unique Id
-        #[serde(rename = "_id")]
-        pub id: String,
-        /// Unique value generated by client sending this message
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub nonce: Option<String>,
-        /// Id of the channel this message was sent in
-        pub channel: String,
-        /// Id of the user or webhook that sent this message
-        pub author: String,
-        /// The webhook that sent this message
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub webhook: Option<MessageWebhook>,
-        /// Message content
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub content: Option<String>,
-        /// System message
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub system: Option<SystemMessage>,
-        /// Array of attachments
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub attachments: Option<Vec<File>>,
-        /// Time at which this message was last edited
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub edited: Option<Timestamp>,
-        /// Attached embeds to this message
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub embeds: Option<Vec<Embed>>,
-        /// Array of user ids mentioned in this message
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub mentions: Option<Vec<String>>,
-        /// Array of message ids this message is replying to
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub replies: Option<Vec<String>>,
-        /// Hashmap of emoji IDs to array of user IDs
-        #[serde(skip_serializing_if = "IndexMap::is_empty", default)]
-        pub reactions: IndexMap<String, IndexSet<String>>,
-        /// Information about how this message should be interacted with
-        #[serde(skip_serializing_if = "Interactions::is_default", default)]
-        pub interactions: Interactions,
-        /// Name and / or avatar overrides for this message
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub masquerade: Option<Masquerade>,
-    },
-    "PartialMessage"
-);
-
-auto_derived!(
-    /// System Event
-    #[serde(tag = "type")]
-    pub enum SystemMessage {
-        #[serde(rename = "text")]
-        Text { content: String },
-        #[serde(rename = "user_added")]
-        UserAdded { id: String, by: String },
-        #[serde(rename = "user_remove")]
-        UserRemove { id: String, by: String },
-        #[serde(rename = "user_joined")]
-        UserJoined { id: String },
-        #[serde(rename = "user_left")]
-        UserLeft { id: String },
-        #[serde(rename = "user_kicked")]
-        UserKicked { id: String },
-        #[serde(rename = "user_banned")]
-        UserBanned { id: String },
-        #[serde(rename = "channel_renamed")]
-        ChannelRenamed { name: String, by: String },
-        #[serde(rename = "channel_description_changed")]
-        ChannelDescriptionChanged { by: String },
-        #[serde(rename = "channel_icon_changed")]
-        ChannelIconChanged { by: String },
-        #[serde(rename = "channel_ownership_changed")]
-        ChannelOwnershipChanged { from: String, to: String },
-    }
-
-    /// Name and / or avatar override information
-    pub struct Masquerade {
-        /// Replace the display name shown on this message
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub name: Option<String>,
-        /// Replace the avatar shown on this message (URL to image file)
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub avatar: Option<String>,
-        /// Replace the display role colour shown on this message
-        ///
-        /// Must have `ManageRole` permission to use
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub colour: Option<String>,
-    }
-
-    /// Information to guide interactions on this message
-    #[derive(Default)]
-    pub struct Interactions {
-        /// Reactions which should always appear and be distinct
-        #[serde(skip_serializing_if = "Option::is_none", default)]
-        pub reactions: Option<IndexSet<String>>,
-        /// Whether reactions should be restricted to the given list
-        ///
-        /// Can only be set to true if reactions list is of at least length 1
-        #[serde(skip_serializing_if = "crate::if_false", default)]
-        pub restrict_reactions: bool,
-    }
-
-    /// Appended Information
-    pub struct AppendMessage {
-        /// Additional embeds to include in this message
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub embeds: Option<Vec<Embed>>,
-    }
-
-    /// Message Time Period
-    ///
-    /// Filter and sort messages by time
-    #[serde(untagged)]
-    pub enum MessageTimePeriod {
-        Relative {
-            /// Message id to search around
-            ///
-            /// Specifying 'nearby' ignores 'before', 'after' and 'sort'.
-            /// It will also take half of limit rounded as the limits to each side.
-            /// It also fetches the message ID specified.
-            nearby: String,
-        },
-        Absolute {
-            /// Message id before which messages should be fetched
-            before: Option<String>,
-            /// Message id after which messages should be fetched
-            after: Option<String>,
-            /// Message sort direction
-            sort: Option<MessageSort>,
-        },
-    }
-
-    /// Message Filter
-    #[derive(Default)]
-    pub struct MessageFilter {
-        /// Parent channel ID
-        pub channel: Option<String>,
-        /// Message author ID
-        pub author: Option<String>,
-        /// Search query
-        pub query: Option<String>,
-    }
-
-    /// Message Query
-    pub struct MessageQuery {
-        /// Maximum number of messages to fetch
-        ///
-        /// For fetching nearby messages, this is \`(limit + 1)\`.
-        pub limit: Option<i64>,
-        /// Filter to apply
-        #[serde(flatten)]
-        pub filter: MessageFilter,
-        /// Time period to fetch
-        #[serde(flatten)]
-        pub time_period: MessageTimePeriod,
-    }
-);
-
-#[allow(clippy::derivable_impls)]
-impl Default for Message {
-    fn default() -> Self {
-        Self {
-            id: Default::default(),
-            nonce: None,
-            channel: Default::default(),
-            author: Default::default(),
-            webhook: None,
-            content: None,
-            system: None,
-            attachments: None,
-            edited: None,
-            embeds: None,
-            mentions: None,
-            replies: None,
-            reactions: Default::default(),
-            interactions: Default::default(),
-            masquerade: None,
-        }
-    }
-}
-
-#[allow(clippy::disallowed_methods)]
-impl Message {
-    /// Create message from API data
-    pub async fn create_from_api(
-        db: &Database,
-        channel: Channel,
-        data: DataMessageSend,
-        author: MessageAuthor<'_>,
-        mut idempotency: IdempotencyKey,
-        generate_embeds: bool,
-        allow_mentions: bool,
-    ) -> Result<Message> {
-        let config = config().await;
-
-        Message::validate_sum(
-            &data.content,
-            data.embeds.as_deref().unwrap_or_default(),
-            config.features.limits.default.message_length,
-        )?;
-
-        idempotency
-            .consume_nonce(data.nonce)
-            .await
-            .map_err(|_| create_error!(InvalidOperation))?;
-
-        // 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()))
-        {
-            return Err(create_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(create_error!(InvalidProperty));
-                }
-            }
-        }
-
-        let (author_id, webhook) = match &author {
-            MessageAuthor::User(user) => (user.id.clone(), None),
-            MessageAuthor::Webhook(webhook) => (webhook.id.clone(), Some((*webhook).clone())),
-            MessageAuthor::System { .. } => ("00000000000000000000000000".to_string(), None),
-        };
-
-        // Start constructing the message
-        let message_id = Ulid::new().to_string();
-        let mut message = Message {
-            id: message_id.clone(),
-            channel: channel.id(),
-            masquerade: data.masquerade.map(|masquerade| masquerade.into()),
-            interactions: data
-                .interactions
-                .map(|interactions| interactions.into())
-                .unwrap_or_default(),
-            author: author_id,
-            webhook: webhook.map(|w| w.into()),
-            ..Default::default()
-        };
-
-        // Parse mentions in message.
-        let mut mentions = HashSet::new();
-        if allow_mentions {
-            if let Some(content) = &data.content {
-                for capture in RE_MENTION.captures_iter(content) {
-                    if let Some(mention) = capture.get(1) {
-                        mentions.insert(mention.as_str().to_string());
-                    }
-                }
-            }
-        }
-
-        // Verify replies are valid.
-        let mut replies = HashSet::new();
-        if let Some(entries) = data.replies {
-            if entries.len() > config.features.limits.default.message_replies {
-                return Err(create_error!(TooManyReplies {
-                    max: config.features.limits.default.message_replies,
-                }));
-            }
-
-            for ReplyIntent { id, mention } in entries {
-                let message = db.fetch_message(&id).await?;
-
-                if mention && allow_mentions {
-                    mentions.insert(message.author.to_owned());
-                }
-
-                replies.insert(message.id);
-            }
-        }
-
-        if !mentions.is_empty() {
-            message.mentions.replace(mentions.into_iter().collect());
-        }
-
-        if !replies.is_empty() {
-            message
-                .replies
-                .replace(replies.into_iter().collect::<Vec<String>>());
-        }
-
-        // Add attachments to message.
-        let mut attachments = vec![];
-        if data
-            .attachments
-            .as_ref()
-            .is_some_and(|v| v.len() > config.features.limits.default.message_attachments)
-        {
-            return Err(create_error!(TooManyAttachments {
-                max: config.features.limits.default.message_attachments,
-            }));
-        }
-
-        if data
-            .embeds
-            .as_ref()
-            .is_some_and(|v| v.len() > config.features.limits.default.message_embeds)
-        {
-            return Err(create_error!(TooManyEmbeds {
-                max: config.features.limits.default.message_embeds,
-            }));
-        }
-
-        for attachment_id in data.attachments.as_deref().unwrap_or_default() {
-            attachments.push(
-                db.find_and_use_attachment(attachment_id, "attachments", "message", &message_id)
-                    .await?,
-            );
-        }
-
-        if !attachments.is_empty() {
-            message.attachments.replace(attachments);
-        }
-
-        // Process included embeds.
-        for sendable_embed in data.embeds.unwrap_or_default() {
-            message.attach_sendable_embed(db, sendable_embed).await?;
-        }
-
-        // Set content
-        message.content = data.content;
-
-        // Pass-through nonce value for clients
-        message.nonce = Some(idempotency.into_key());
-
-        // Send the message
-        message.send(db, author, &channel, generate_embeds).await?;
-
-        Ok(message)
-    }
-
-    /// Send a message without any notifications
-    pub async fn send_without_notifications(
-        &mut self,
-        db: &Database,
-        is_dm: bool,
-        generate_embeds: bool,
-    ) -> Result<()> {
-        db.insert_message(self).await?;
-
-        // Fan out events
-        EventV1::Message(self.clone().into())
-            .p(self.channel.to_string())
-            .await;
-
-        // Update last_message_id
-        tasks::last_message_id::queue(self.channel.to_string(), self.id.to_string(), is_dm).await;
-
-        // Add mentions for affected users
-        if let Some(mentions) = &self.mentions {
-            for user in mentions {
-                tasks::ack::queue(
-                    self.channel.to_string(),
-                    user.to_string(),
-                    AckEvent::AddMention {
-                        ids: vec![self.id.to_string()],
-                    },
-                )
-                .await;
-            }
-        }
-
-        // Generate embeds
-        if generate_embeds {
-            if let Some(content) = &self.content {
-                tasks::process_embeds::queue(
-                    self.channel.to_string(),
-                    self.id.to_string(),
-                    content.clone(),
-                )
-                .await;
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Send a message
-    pub async fn send(
-        &mut self,
-        db: &Database,
-        author: MessageAuthor<'_>,
-        channel: &Channel,
-        generate_embeds: bool,
-    ) -> Result<()> {
-        self.send_without_notifications(
-            db,
-            matches!(channel, Channel::DirectMessage { .. }),
-            generate_embeds,
-        )
-        .await?;
-
-        // Push out Web Push notifications
-        crate::tasks::web_push::queue(
-            {
-                match channel {
-                    Channel::DirectMessage { recipients, .. }
-                    | Channel::Group { recipients, .. } => recipients.clone(),
-                    Channel::TextChannel { .. } => self.mentions.clone().unwrap_or_default(),
-                    _ => vec![],
-                }
-            },
-            PushNotification::from(self.clone().into(), Some(author), &channel.id()).await,
-        )
-        .await;
-
-        Ok(())
-    }
-
-    /// Create text embed from sendable embed
-    pub async fn create_embed(&self, db: &Database, embed: SendableEmbed) -> Result<Embed> {
-        embed.validate().map_err(|error| {
-            create_error!(FailedValidation {
-                error: error.to_string()
-            })
-        })?;
-
-        let media = if let Some(id) = embed.media {
-            Some(
-                db.find_and_use_attachment(&id, "attachments", "message", &self.id)
-                    .await?,
-            )
-        } else {
-            None
-        };
-
-        Ok(Embed::Text(Text {
-            icon_url: embed.icon_url,
-            url: embed.url,
-            title: embed.title,
-            description: embed.description,
-            media: media.map(|m| m.into()),
-            colour: embed.colour,
-        }))
-    }
-
-    /// Update message data
-    pub async fn update(&mut self, db: &Database, partial: PartialMessage) -> Result<()> {
-        self.apply_options(partial.clone());
-        db.update_message(&self.id, &partial).await?;
-
-        EventV1::MessageUpdate {
-            id: self.id.clone(),
-            channel: self.channel.clone(),
-            data: partial.into(),
-        }
-        .p(self.channel.clone())
-        .await;
-
-        Ok(())
-    }
-
-    /// Helper function to fetch many messages with users
-    pub async fn fetch_with_users(
-        db: &Database,
-        query: MessageQuery,
-        perspective: &User,
-        include_users: Option<bool>,
-        server_id: Option<String>,
-    ) -> Result<BulkMessageResponse> {
-        let messages: Vec<v0::Message> = db
-            .fetch_messages(query)
-            .await?
-            .into_iter()
-            .map(Into::into)
-            .collect();
-
-        if let Some(true) = include_users {
-            let user_ids = messages
-                .iter()
-                .map(|m| m.author.clone())
-                .collect::<HashSet<String>>()
-                .into_iter()
-                .collect::<Vec<String>>();
-            let users = User::fetch_many_ids_as_mutuals(db, perspective, &user_ids).await?;
-
-            Ok(BulkMessageResponse::MessagesAndUsers {
-                messages,
-                users,
-                members: if let Some(server_id) = server_id {
-                    Some(
-                        db.fetch_members(&server_id, &user_ids)
-                            .await?
-                            .into_iter()
-                            .map(Into::into)
-                            .collect(),
-                    )
-                } else {
-                    None
-                },
-            })
-        } else {
-            Ok(BulkMessageResponse::JustMessages(messages))
-        }
-    }
-
-    /// Append content to message
-    pub async fn append(
-        db: &Database,
-        id: String,
-        channel: String,
-        append: AppendMessage,
-    ) -> Result<()> {
-        db.append_message(&id, &append).await?;
-
-        EventV1::MessageAppend {
-            id,
-            channel: channel.to_string(),
-            append: append.into(),
-        }
-        .p(channel)
-        .await;
-
-        Ok(())
-    }
-
-    /// Convert sendable embed to text embed and attach to message
-    pub async fn attach_sendable_embed(
-        &mut self,
-        db: &Database,
-        embed: v0::SendableEmbed,
-    ) -> Result<()> {
-        let media: Option<v0::File> = if let Some(id) = embed.media {
-            Some(
-                db.find_and_use_attachment(&id, "attachments", "message", &self.id)
-                    .await?
-                    .into(),
-            )
-        } else {
-            None
-        };
-
-        let embed = v0::Embed::Text(v0::Text {
-            icon_url: embed.icon_url,
-            url: embed.url,
-            title: embed.title,
-            description: embed.description,
-            media,
-            colour: embed.colour,
-        });
-
-        if let Some(embeds) = &mut self.embeds {
-            embeds.push(embed);
-        } else {
-            self.embeds = Some(vec![embed]);
-        }
-
-        Ok(())
-    }
-
-    /// Add a reaction to a message
-    pub async fn add_reaction(&self, db: &Database, user: &User, emoji: &str) -> Result<()> {
-        // Check how many reactions are already on the message
-        let config = config().await;
-        if self.reactions.len() >= config.features.limits.default.message_reactions
-            && !self.reactions.contains_key(emoji)
-        {
-            return Err(create_error!(InvalidOperation));
-        }
-
-        // Check if the emoji is whitelisted
-        if !self.interactions.can_use(emoji) {
-            return Err(create_error!(InvalidOperation));
-        }
-
-        // Check if the emoji is usable by us
-        if !Emoji::can_use(db, emoji).await? {
-            return Err(create_error!(InvalidOperation));
-        }
-
-        // Send reaction event
-        EventV1::MessageReact {
-            id: self.id.to_string(),
-            channel_id: self.channel.to_string(),
-            user_id: user.id.to_string(),
-            emoji_id: emoji.to_string(),
-        }
-        .p(self.channel.to_string())
-        .await;
-
-        // Add emoji
-        db.add_reaction(&self.id, emoji, &user.id).await
-    }
-
-    /// Validate the sum of content of a message is under threshold
-    pub fn validate_sum(
-        content: &Option<String>,
-        embeds: &[SendableEmbed],
-        max_length: usize,
-    ) -> Result<()> {
-        let mut running_total = 0;
-        if let Some(content) = content {
-            running_total += content.len();
-        }
-
-        for embed in embeds {
-            if let Some(desc) = &embed.description {
-                running_total += desc.len();
-            }
-        }
-
-        if running_total <= max_length {
-            Ok(())
-        } else {
-            Err(create_error!(PayloadTooLarge))
-        }
-    }
-
-    /// Delete a message
-    pub async fn delete(self, db: &Database) -> Result<()> {
-        let file_ids: Vec<String> = self
-            .attachments
-            .map(|files| files.iter().map(|file| file.id.to_string()).collect())
-            .unwrap_or_default();
-
-        if !file_ids.is_empty() {
-            db.mark_attachments_as_deleted(&file_ids).await?;
-        }
-
-        db.delete_message(&self.id).await?;
-
-        EventV1::MessageDelete {
-            id: self.id,
-            channel: self.channel.clone(),
-        }
-        .p(self.channel)
-        .await;
-        Ok(())
-    }
-
-    /// Bulk delete messages
-    pub async fn bulk_delete(db: &Database, channel: &str, ids: Vec<String>) -> Result<()> {
-        let valid_ids = db
-            .fetch_messages_by_id(&ids)
-            .await?
-            .into_iter()
-            .filter(|msg| msg.channel == channel)
-            .map(|msg| msg.id)
-            .collect::<Vec<String>>();
-
-        db.delete_messages(channel, &valid_ids).await?;
-        EventV1::BulkMessageDelete {
-            channel: channel.to_string(),
-            ids: valid_ids,
-        }
-        .p(channel.to_string())
-        .await;
-        Ok(())
-    }
-
-    /// Remove a reaction from a message
-    pub async fn remove_reaction(&self, db: &Database, user: &str, emoji: &str) -> Result<()> {
-        // Check if it actually exists
-        let empty = if let Some(users) = self.reactions.get(emoji) {
-            if !users.contains(user) {
-                return Err(create_error!(NotFound));
-            }
-
-            users.len() == 1
-        } else {
-            return Err(create_error!(NotFound));
-        };
-
-        // Send reaction event
-        EventV1::MessageUnreact {
-            id: self.id.to_string(),
-            channel_id: self.channel.to_string(),
-            user_id: user.to_string(),
-            emoji_id: emoji.to_string(),
-        }
-        .p(self.channel.to_string())
-        .await;
-
-        if empty {
-            // If empty, remove the reaction entirely
-            db.clear_reaction(&self.id, emoji).await
-        } else {
-            // Otherwise only remove that one reaction
-            db.remove_reaction(&self.id, emoji, user).await
-        }
-    }
-
-    /// Remove a reaction from a message
-    pub async fn clear_reaction(&self, db: &Database, emoji: &str) -> Result<()> {
-        // Send reaction event
-        EventV1::MessageRemoveReaction {
-            id: self.id.to_string(),
-            channel_id: self.channel.to_string(),
-            emoji_id: emoji.to_string(),
-        }
-        .p(self.channel.to_string())
-        .await;
-
-        // Write to database
-        db.clear_reaction(&self.id, emoji).await
-    }
-}
-
-impl SystemMessage {
-    pub fn into_message(self, channel: String) -> Message {
-        Message {
-            id: Ulid::new().to_string(),
-            channel,
-            author: "00000000000000000000000000".to_string(),
-            system: Some(self),
-
-            ..Default::default()
-        }
-    }
-}
-
-impl Interactions {
-    /// Validate interactions info is correct
-    pub async fn validate(&self, db: &Database, permissions: &PermissionValue) -> Result<()> {
-        let config = config().await;
-
-        if let Some(reactions) = &self.reactions {
-            permissions.throw_if_lacking_channel_permission(ChannelPermission::React)?;
-
-            if reactions.len() > config.features.limits.default.message_reactions {
-                return Err(create_error!(InvalidOperation));
-            }
-
-            for reaction in reactions {
-                if !Emoji::can_use(db, reaction).await? {
-                    return Err(create_error!(InvalidOperation));
-                }
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Check if we can use a given emoji to react
-    pub fn can_use(&self, emoji: &str) -> bool {
-        if self.restrict_reactions {
-            if let Some(reactions) = &self.reactions {
-                reactions.contains(emoji)
-            } else {
-                false
-            }
-        } else {
-            true
-        }
-    }
-
-    /// Check if default initialisation of fields
-    pub fn is_default(&self) -> bool {
-        !self.restrict_reactions && self.reactions.is_none()
-    }
-}

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

@@ -1,278 +0,0 @@
-use futures::future::try_join_all;
-use indexmap::IndexSet;
-use revolt_result::Result;
-
-use crate::{AppendMessage, Message, MessageQuery, PartialMessage, ReferenceDb};
-
-use super::AbstractMessages;
-
-#[async_trait]
-impl AbstractMessages for ReferenceDb {
-    /// Insert a new message into the database
-    async fn insert_message(&self, message: &Message) -> Result<()> {
-        let mut messages = self.messages.lock().await;
-        if messages.contains_key(&message.id) {
-            Err(create_database_error!("insert", "message"))
-        } else {
-            messages.insert(message.id.to_string(), message.clone());
-            Ok(())
-        }
-    }
-
-    /// Fetch a message by its id
-    async fn fetch_message(&self, id: &str) -> Result<Message> {
-        let messages = self.messages.lock().await;
-        messages
-            .get(id)
-            .cloned()
-            .ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch multiple messages by given query
-    async fn fetch_messages(&self, query: MessageQuery) -> Result<Vec<Message>> {
-        let messages = self.messages.lock().await;
-        let matched_messages = messages
-            .values()
-            .filter(|message| {
-                if let Some(channel) = &query.filter.channel {
-                    if &message.channel != channel {
-                        return false;
-                    }
-                }
-
-                if let Some(author) = &query.filter.author {
-                    if &message.author != author {
-                        return false;
-                    }
-                }
-
-                if let Some(query) = &query.filter.query {
-                    if let Some(content) = &message.content {
-                        if !content.to_lowercase().contains(query) {
-                            return false;
-                        }
-                    } else {
-                        return false;
-                    }
-                }
-
-                true
-            })
-            .cloned()
-            .collect();
-
-        // FIXME: sorting, etc (will be required for tests)
-
-        Ok(matched_messages)
-
-        /*
-        // 2. Find query limit
-        let limit = query.limit.unwrap_or(50);
-
-        // 3. Apply message time period
-        match query.time_period {
-            MessageTimePeriod::Relative { nearby } => {
-                // 3.1. Prepare filters
-                let mut older_message_filter = filter.clone();
-                let mut newer_message_filter = filter;
-
-                older_message_filter.insert(
-                    "_id",
-                    doc! {
-                        "$lt": &nearby
-                    },
-                );
-
-                newer_message_filter.insert(
-                    "_id",
-                    doc! {
-                        "$gte": &nearby
-                    },
-                );
-
-                // 3.2. Execute in both directions
-                let (a, b) = try_join!(
-                    self.find_with_options::<_, Message>(
-                        COL,
-                        newer_message_filter,
-                        FindOptions::builder()
-                            .limit(limit / 2 + 1)
-                            .sort(doc! {
-                                "_id": 1_i32
-                            })
-                            .build(),
-                    ),
-                    self.find_with_options::<_, Message>(
-                        COL,
-                        older_message_filter,
-                        FindOptions::builder()
-                            .limit(limit / 2)
-                            .sort(doc! {
-                                "_id": -1_i32
-                            })
-                            .build(),
-                    )
-                )
-                .map_err(|_| create_database_error!("find", COL))?;
-
-                Ok([a, b].concat())
-            }
-            MessageTimePeriod::Absolute {
-                before,
-                after,
-                sort,
-            } => {
-                // 3.1. Apply message ID filter
-                if let Some(doc) = match (before, after) {
-                    (Some(before), Some(after)) => Some(doc! {
-                        "$lt": before,
-                        "$gt": after
-                    }),
-                    (Some(before), _) => Some(doc! {
-                        "$lt": before
-                    }),
-                    (_, Some(after)) => Some(doc! {
-                        "$gt": after
-                    }),
-                    _ => None,
-                } {
-                    filter.insert("_id", doc);
-                }
-
-                // 3.2. Execute with given message sort
-                self.find_with_options(
-                    COL,
-                    filter,
-                    FindOptions::builder()
-                        .limit(limit)
-                        .sort(match sort.unwrap_or(MessageSort::Latest) {
-                            // Sort by relevance, fallback to latest
-                            MessageSort::Relevance => {
-                                if is_search_query {
-                                    doc! {
-                                        "score": {
-                                            "$meta": "textScore"
-                                        }
-                                    }
-                                } else {
-                                    doc! {
-                                        "_id": -1_i32
-                                    }
-                                }
-                            }
-                            // Sort by latest first
-                            MessageSort::Latest => doc! {
-                                "_id": -1_i32
-                            },
-                            // Sort by oldest first
-                            MessageSort::Oldest => doc! {
-                                "_id": 1_i32
-                            },
-                        })
-                        .build(),
-                )
-                .await
-                .map_err(|_| create_database_error!("find", COL))
-            }
-        }*/
-    }
-
-    /// Fetch multiple messages by given IDs
-    async fn fetch_messages_by_id(&self, ids: &[String]) -> Result<Vec<Message>> {
-        try_join_all(ids.iter().map(|id| self.fetch_message(id))).await
-    }
-
-    /// Update a given message with new information
-    async fn update_message(&self, id: &str, message: &PartialMessage) -> Result<()> {
-        let mut messages = self.messages.lock().await;
-        if let Some(message_data) = messages.get_mut(id) {
-            message_data.apply_options(message.to_owned());
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Append information to a given message
-    async fn append_message(&self, id: &str, append: &AppendMessage) -> Result<()> {
-        let mut messages = self.messages.lock().await;
-        if let Some(message_data) = messages.get_mut(id) {
-            if let Some(embeds) = &append.embeds {
-                if !embeds.is_empty() {
-                    if let Some(embeds_data) = &mut message_data.embeds {
-                        embeds_data.extend(embeds.clone());
-                    } else {
-                        message_data.embeds = Some(embeds.clone());
-                    }
-                }
-            }
-
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Add a new reaction to a message
-    async fn add_reaction(&self, id: &str, emoji: &str, user: &str) -> Result<()> {
-        let mut messages = self.messages.lock().await;
-        if let Some(message) = messages.get_mut(id) {
-            if let Some(users) = message.reactions.get_mut(emoji) {
-                users.insert(user.to_string());
-            } else {
-                message
-                    .reactions
-                    .insert(emoji.to_string(), IndexSet::from([user.to_string()]));
-            }
-
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Remove a reaction from a message
-    async fn remove_reaction(&self, id: &str, emoji: &str, user: &str) -> Result<()> {
-        let mut messages = self.messages.lock().await;
-        if let Some(message) = messages.get_mut(id) {
-            if let Some(users) = message.reactions.get_mut(emoji) {
-                users.remove(&user.to_string());
-            }
-
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Remove reaction from a message
-    async fn clear_reaction(&self, id: &str, emoji: &str) -> Result<()> {
-        let mut messages = self.messages.lock().await;
-        if let Some(message) = messages.get_mut(id) {
-            message.reactions.remove(emoji);
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Delete a message from the database by its id
-    async fn delete_message(&self, id: &str) -> Result<()> {
-        let mut messages = self.messages.lock().await;
-        if messages.remove(id).is_some() {
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Delete messages from a channel by their ids and corresponding channel id
-    async fn delete_messages(&self, channel: &str, ids: &[String]) -> Result<()> {
-        self.messages
-            .lock()
-            .await
-            .retain(|id, message| message.channel != channel && !ids.contains(id));
-
-        Ok(())
-    }
-}

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

@@ -1,74 +0,0 @@
-mod admin_migrations;
-mod bots;
-mod channel_invites;
-mod channel_unreads;
-mod channel_webhooks;
-mod channels;
-mod emojis;
-mod files;
-mod messages;
-mod ratelimit_events;
-mod safety_reports;
-mod safety_snapshots;
-mod server_bans;
-mod server_members;
-mod servers;
-mod user_settings;
-mod users;
-
-pub use admin_migrations::*;
-pub use bots::*;
-pub use channel_invites::*;
-pub use channel_unreads::*;
-pub use channel_webhooks::*;
-pub use channels::*;
-pub use emojis::*;
-pub use files::*;
-pub use messages::*;
-pub use ratelimit_events::*;
-pub use safety_reports::*;
-pub use safety_snapshots::*;
-pub use server_bans::*;
-pub use server_members::*;
-pub use servers::*;
-pub use user_settings::*;
-pub use users::*;
-
-use crate::{Database, MongoDb, ReferenceDb};
-
-pub trait AbstractDatabase:
-    Sync
-    + Send
-    + admin_migrations::AbstractMigrations
-    + bots::AbstractBots
-    + channels::AbstractChannels
-    + channel_invites::AbstractChannelInvites
-    + channel_unreads::AbstractChannelUnreads
-    + channel_webhooks::AbstractWebhooks
-    + emojis::AbstractEmojis
-    + files::AbstractAttachments
-    + messages::AbstractMessages
-    + ratelimit_events::AbstractRatelimitEvents
-    + safety_reports::AbstractReport
-    + safety_snapshots::AbstractSnapshot
-    + server_bans::AbstractServerBans
-    + server_members::AbstractServerMembers
-    + servers::AbstractServers
-    + user_settings::AbstractUserSettings
-    + users::AbstractUsers
-{
-}
-
-impl AbstractDatabase for ReferenceDb {}
-impl AbstractDatabase for MongoDb {}
-
-impl std::ops::Deref for Database {
-    type Target = dyn AbstractDatabase;
-
-    fn deref(&self) -> &Self::Target {
-        match &self {
-            Database::Reference(dummy) => dummy,
-            Database::MongoDb(mongo) => mongo,
-        }
-    }
-}

crates/core/database/src/models/ratelimit_events/mod.rs

@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;

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

@@ -1,47 +0,0 @@
-use std::fmt;
-
-use revolt_result::Result;
-use ulid::Ulid;
-
-use crate::Database;
-
-auto_derived!(
-    /// Ratelimit Event
-    pub struct RatelimitEvent {
-        /// Id
-        #[serde(rename = "_id")]
-        pub id: String,
-        /// Relevant Object Id
-        pub target_id: String,
-        /// Type of event
-        pub event_type: RatelimitEventType,
-    }
-
-    /// Event type
-    pub enum RatelimitEventType {
-        DiscriminatorChange,
-    }
-);
-
-impl fmt::Display for RatelimitEventType {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(self, f)
-    }
-}
-
-#[allow(clippy::disallowed_methods)]
-impl RatelimitEvent {
-    /// Create ratelimit event
-    pub async fn create(
-        db: &Database,
-        target_id: String,
-        event_type: RatelimitEventType,
-    ) -> Result<()> {
-        db.insert_ratelimit_event(&RatelimitEvent {
-            id: Ulid::new().to_string(),
-            target_id,
-            event_type,
-        })
-        .await
-    }
-}

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

@@ -1,20 +0,0 @@
-use std::time::Duration;
-
-use crate::{revolt_result::Result, RatelimitEvent, RatelimitEventType};
-mod mongodb;
-mod reference;
-
-#[async_trait]
-pub trait AbstractRatelimitEvents: Sync + Send {
-    /// Insert a new ratelimit event
-    async fn insert_ratelimit_event(&self, event: &RatelimitEvent) -> Result<()>;
-
-    /// Count number of events in given duration and check if we've hit the limit
-    async fn has_ratelimited(
-        &self,
-        target_id: &str,
-        event_type: RatelimitEventType,
-        period: Duration,
-        count: usize,
-    ) -> Result<bool>;
-}

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

@@ -1,40 +0,0 @@
-use std::time::{Duration, SystemTime};
-
-use super::AbstractRatelimitEvents;
-use crate::{MongoDb, RatelimitEvent, RatelimitEventType};
-use revolt_result::Result;
-use ulid::Ulid;
-
-static COL: &str = "ratelimit_events";
-
-#[async_trait]
-impl AbstractRatelimitEvents for MongoDb {
-    /// Insert a new ratelimit event
-    async fn insert_ratelimit_event(&self, event: &RatelimitEvent) -> Result<()> {
-        query!(self, insert_one, COL, &event).map(|_| ())
-    }
-
-    /// Count number of events in given duration and check if we've hit the limit
-    async fn has_ratelimited(
-        &self,
-        target_id: &str,
-        event_type: RatelimitEventType,
-        period: Duration,
-        count: usize,
-    ) -> Result<bool> {
-        self.col::<RatelimitEvent>(COL)
-            .count_documents(
-                doc! {
-                    "_id": {
-                        "$gte": Ulid::from_datetime(SystemTime::now() - period).to_string()
-                    },
-                    "target_id": target_id,
-                    "event_type": event_type.to_string()
-                },
-                None,
-            )
-            .await
-            .map(|c| c as usize >= count)
-            .map_err(|_| create_database_error!("count_documents", COL))
-    }
-}

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

@@ -1,46 +0,0 @@
-use std::cmp::Ordering;
-use std::time::Duration;
-use std::time::SystemTime;
-
-use super::AbstractRatelimitEvents;
-use crate::RatelimitEvent;
-use crate::RatelimitEventType;
-use crate::ReferenceDb;
-use revolt_result::Result;
-use ulid::Ulid;
-
-#[async_trait]
-impl AbstractRatelimitEvents for ReferenceDb {
-    /// Insert a new ratelimit event
-    async fn insert_ratelimit_event(&self, event: &RatelimitEvent) -> Result<()> {
-        let mut ratelimit_events = self.ratelimit_events.lock().await;
-        if ratelimit_events.contains_key(&event.id) {
-            Err(create_database_error!("insert", "message"))
-        } else {
-            ratelimit_events.insert(event.id.to_string(), event.clone());
-            Ok(())
-        }
-    }
-
-    /// Count number of events in given duration and check if we've hit the limit
-    async fn has_ratelimited(
-        &self,
-        target_id: &str,
-        event_type: RatelimitEventType,
-        period: Duration,
-        count: usize,
-    ) -> Result<bool> {
-        let ratelimit_events = self.ratelimit_events.lock().await;
-        let gte_cmp_id = Ulid::from_datetime(SystemTime::now() - period).to_string();
-
-        Ok(ratelimit_events
-            .iter()
-            .filter(|(id, event)| {
-                id.cmp(&&gte_cmp_id) == Ordering::Greater
-                    && event.target_id == target_id
-                    && event.event_type == event_type
-            })
-            .count()
-            >= count)
-    }
-}

crates/core/database/src/models/safety_reports/mod.rs

@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;

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

@@ -1,22 +0,0 @@
-use revolt_models::v0::{ReportStatus, ReportedContent};
-
-auto_derived!(
-    /// User-generated platform moderation report
-    pub struct Report {
-        /// Unique Id
-        #[serde(rename = "_id")]
-        pub id: String,
-        /// Id of the user creating this report
-        pub author_id: String,
-        /// Reported content
-        pub content: ReportedContent,
-        /// Additional report context
-        pub additional_context: String,
-        /// Status of the report
-        #[serde(flatten)]
-        pub status: ReportStatus,
-        /// Additional notes included on the report
-        #[serde(default)]
-        pub notes: String,
-    }
-);

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

@@ -1,12 +0,0 @@
-use revolt_result::Result;
-
-use crate::Report;
-
-mod mongodb;
-mod reference;
-
-#[async_trait]
-pub trait AbstractReport: Sync + Send {
-    /// Insert a new report into the database
-    async fn insert_report(&self, report: &Report) -> Result<()>;
-}

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

@@ -1,16 +0,0 @@
-use revolt_result::Result;
-
-use crate::MongoDb;
-use crate::Report;
-
-use super::AbstractReport;
-
-static COL: &str = "safety_reports";
-
-#[async_trait]
-impl AbstractReport for MongoDb {
-    /// Insert a new report into the database
-    async fn insert_report(&self, report: &Report) -> Result<()> {
-        query!(self, insert_one, COL, &report).map(|_| ())
-    }
-}

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

@@ -1,20 +0,0 @@
-use revolt_result::Result;
-
-use crate::ReferenceDb;
-use crate::Report;
-
-use super::AbstractReport;
-
-#[async_trait]
-impl AbstractReport for ReferenceDb {
-    /// Insert a new report into the database
-    async fn insert_report(&self, report: &Report) -> Result<()> {
-        let mut reports = self.safety_reports.lock().await;
-        if reports.contains_key(&report.id) {
-            Err(create_database_error!("insert", "report"))
-        } else {
-            reports.insert(report.id.to_string(), report.clone());
-            Ok(())
-        }
-    }
-}

crates/core/database/src/models/safety_snapshots/mod.rs

@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;

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

@@ -1,121 +0,0 @@
-use revolt_models::v0::MessageSort;
-use revolt_result::Result;
-
-use crate::{Database, Message, MessageFilter, MessageQuery, MessageTimePeriod, Server, User};
-
-auto_derived!(
-    /// Snapshot of some content
-    pub struct Snapshot {
-        /// Unique Id
-        #[serde(rename = "_id")]
-        pub id: String,
-        /// Report parent Id
-        pub report_id: String,
-        /// Snapshot of content
-        pub content: SnapshotContent,
-    }
-
-    /// Enum to map into different models
-    /// that can be saved in a snapshot
-    #[serde(tag = "_type")]
-    pub enum SnapshotContent {
-        Message {
-            /// Context before the message
-            #[serde(rename = "_prior_context", default)]
-            prior_context: Vec<Message>,
-
-            /// Context after the message
-            #[serde(rename = "_leading_context", default)]
-            leading_context: Vec<Message>,
-
-            /// Message
-            #[serde(flatten)]
-            message: Message,
-        },
-        Server(Server),
-        User(User),
-    }
-);
-
-impl SnapshotContent {
-    /// Generate snapshot from a given message
-    pub async fn generate_from_message(
-        db: &Database,
-        message: Message,
-    ) -> Result<(SnapshotContent, Vec<String>)> {
-        // 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?;
-
-        Ok((
-            SnapshotContent::Message {
-                message,
-                prior_context: prior_context.into_iter().map(Into::into).collect(),
-                leading_context: leading_context.into_iter().map(Into::into).collect(),
-            },
-            files,
-        ))
-    }
-
-    /// Generate snapshot from a given server
-    pub fn generate_from_server(server: Server) -> Result<(SnapshotContent, Vec<String>)> {
-        // 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();
-
-        Ok((SnapshotContent::Server(server), files))
-    }
-
-    /// Generate snapshot from a given user
-    pub fn generate_from_user(user: User) -> Result<(SnapshotContent, Vec<String>)> {
-        // Collect user's avatar and profile background
-        let files = [
-            user.avatar.as_ref(),
-            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();
-
-        Ok((SnapshotContent::User(user), files))
-    }
-}

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

@@ -1,16 +0,0 @@
-use revolt_result::Result;
-
-use crate::MongoDb;
-use crate::Snapshot;
-
-use super::AbstractSnapshot;
-
-static COL: &str = "safety_snapshots";
-
-#[async_trait]
-impl AbstractSnapshot for MongoDb {
-    /// Insert a new snapshot into the database
-    async fn insert_snapshot(&self, snapshot: &Snapshot) -> Result<()> {
-        query!(self, insert_one, COL, &snapshot).map(|_| ())
-    }
-}

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

@@ -1,20 +0,0 @@
-use revolt_result::Result;
-
-use crate::ReferenceDb;
-use crate::Snapshot;
-
-use super::AbstractSnapshot;
-
-#[async_trait]
-impl AbstractSnapshot for ReferenceDb {
-    /// Insert a new report into the database
-    async fn insert_snapshot(&self, snapshot: &Snapshot) -> Result<()> {
-        let mut snapshots = self.safety_snapshots.lock().await;
-        if snapshots.contains_key(&snapshot.id) {
-            Err(create_database_error!("insert", "snapshot"))
-        } else {
-            snapshots.insert(snapshot.id.to_string(), snapshot.clone());
-            Ok(())
-        }
-    }
-}

crates/core/database/src/models/server_bans/mod.rs

@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;

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

@@ -1,35 +0,0 @@
-use revolt_result::Result;
-
-use crate::{Database, MemberCompositeKey, Server};
-
-auto_derived!(
-    /// Server Ban
-    pub struct ServerBan {
-        /// Unique member id
-        #[serde(rename = "_id")]
-        pub id: MemberCompositeKey,
-        /// Reason for ban creation
-        pub reason: Option<String>,
-    }
-);
-
-impl ServerBan {
-    /// Create ban
-    pub async fn create(
-        db: &Database,
-        server: &Server,
-        user_id: &str,
-        reason: Option<String>,
-    ) -> Result<ServerBan> {
-        let ban = ServerBan {
-            id: MemberCompositeKey {
-                server: server.id.to_string(),
-                user: user_id.to_string(),
-            },
-            reason,
-        };
-
-        db.insert_ban(&ban).await?;
-        Ok(ban)
-    }
-}

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

@@ -1,56 +0,0 @@
-use revolt_result::Result;
-
-use crate::MongoDb;
-use crate::{MemberCompositeKey, ServerBan};
-
-use super::AbstractServerBans;
-
-static COL: &str = "server_bans";
-
-#[async_trait]
-impl AbstractServerBans for MongoDb {
-    /// Insert new ban into database
-    async fn insert_ban(&self, ban: &ServerBan) -> Result<()> {
-        query!(self, insert_one, COL, &ban).map(|_| ())
-    }
-
-    /// Fetch a server ban by server and user id
-    async fn fetch_ban(&self, server_id: &str, user_id: &str) -> Result<ServerBan> {
-        query!(
-            self,
-            find_one,
-            COL,
-            doc! {
-                "_id.server": server_id,
-                "_id.user": user_id
-            }
-        )?
-        .ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch all bans in a server
-    async fn fetch_bans(&self, server_id: &str) -> Result<Vec<ServerBan>> {
-        query!(
-            self,
-            find,
-            COL,
-            doc! {
-                "_id.server": server_id
-            }
-        )
-    }
-
-    /// Delete a ban from the database
-    async fn delete_ban(&self, id: &MemberCompositeKey) -> Result<()> {
-        query!(
-            self,
-            delete_one,
-            COL,
-            doc! {
-                "_id.server": &id.server,
-                "_id.user": &id.user
-            }
-        )
-        .map(|_| ())
-    }
-}

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

@@ -1,52 +0,0 @@
-use revolt_result::Result;
-
-use crate::ReferenceDb;
-use crate::{MemberCompositeKey, ServerBan};
-
-use super::AbstractServerBans;
-
-#[async_trait]
-impl AbstractServerBans for ReferenceDb {
-    /// Insert new ban into database
-    async fn insert_ban(&self, ban: &ServerBan) -> Result<()> {
-        let mut server_bans = self.server_bans.lock().await;
-        if server_bans.contains_key(&ban.id) {
-            Err(create_database_error!("insert", "ban"))
-        } else {
-            server_bans.insert(ban.id.clone(), ban.clone());
-            Ok(())
-        }
-    }
-
-    /// Fetch a server ban by server and user id
-    async fn fetch_ban(&self, server_id: &str, user_id: &str) -> Result<ServerBan> {
-        let server_bans = self.server_bans.lock().await;
-        server_bans
-            .get(&MemberCompositeKey {
-                server: server_id.to_string(),
-                user: user_id.to_string(),
-            })
-            .cloned()
-            .ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch all bans in a server
-    async fn fetch_bans(&self, server_id: &str) -> Result<Vec<ServerBan>> {
-        let server_bans = self.server_bans.lock().await;
-        Ok(server_bans
-            .values()
-            .filter(|member| member.id.server == server_id)
-            .cloned()
-            .collect())
-    }
-
-    /// Delete a ban from the database
-    async fn delete_ban(&self, id: &MemberCompositeKey) -> Result<()> {
-        let mut server_bans = self.server_bans.lock().await;
-        if server_bans.remove(id).is_some() {
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-}

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

@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;

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

@@ -1,261 +0,0 @@
-use iso8601_timestamp::Timestamp;
-use revolt_permissions::{calculate_channel_permissions, ChannelPermission};
-use revolt_result::{create_error, Result};
-
-use crate::{
-    events::client::EventV1, util::permissions::DatabasePermissionQuery, Channel, Database, File,
-    Server, SystemMessage, User,
-};
-
-auto_derived_partial!(
-    /// Server Member
-    pub struct Member {
-        /// Unique member id
-        #[serde(rename = "_id")]
-        pub id: MemberCompositeKey,
-
-        /// Time at which this user joined the server
-        pub joined_at: Timestamp,
-
-        /// Member's nickname
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub nickname: Option<String>,
-        /// Avatar attachment
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub avatar: Option<File>,
-
-        /// Member's roles
-        #[serde(skip_serializing_if = "Vec::is_empty", default)]
-        pub roles: Vec<String>,
-        /// Timestamp this member is timed out until
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub timeout: Option<Timestamp>,
-    },
-    "PartialMember"
-);
-
-auto_derived!(
-    /// Composite primary key consisting of server and user id
-    #[derive(Hash, Default)]
-    pub struct MemberCompositeKey {
-        /// Server Id
-        pub server: String,
-        /// User Id
-        pub user: String,
-    }
-
-    /// Optional fields on server member object
-    pub enum FieldsMember {
-        Nickname,
-        Avatar,
-        Roles,
-        Timeout,
-    }
-
-    /// Member removal intention
-    pub enum RemovalIntention {
-        Leave,
-        Kick,
-        Ban,
-    }
-);
-
-impl Default for Member {
-    fn default() -> Self {
-        Self {
-            id: Default::default(),
-            joined_at: Timestamp::now_utc(),
-            nickname: None,
-            avatar: None,
-            roles: vec![],
-            timeout: None,
-        }
-    }
-}
-
-#[allow(clippy::disallowed_methods)]
-impl Member {
-    /// Create a new member in a server
-    pub async fn create(
-        db: &Database,
-        server: &Server,
-        user: &User,
-        channels: Option<Vec<Channel>>,
-    ) -> Result<Vec<Channel>> {
-        if db.fetch_ban(&server.id, &user.id).await.is_ok() {
-            return Err(create_error!(Banned));
-        }
-
-        if db.fetch_member(&server.id, &user.id).await.is_ok() {
-            return Err(create_error!(AlreadyInServer));
-        }
-
-        let member = Member {
-            id: MemberCompositeKey {
-                server: server.id.to_string(),
-                user: user.id.to_string(),
-            },
-            ..Default::default()
-        };
-
-        db.insert_member(&member).await?;
-
-        let should_fetch = channels.is_none();
-        let mut channels = channels.unwrap_or_default();
-
-        if should_fetch {
-            let query = DatabasePermissionQuery::new(db, user).server(server);
-            let existing_channels = db.fetch_channels(&server.channels).await?;
-
-            for channel in existing_channels {
-                let mut channel_query = query.clone().channel(&channel);
-
-                if calculate_channel_permissions(&mut channel_query)
-                    .await
-                    .has_channel_permission(ChannelPermission::ViewChannel)
-                {
-                    channels.push(channel);
-                }
-            }
-        }
-
-        let emojis = db.fetch_emoji_by_parent_id(&server.id).await?;
-
-        EventV1::ServerMemberJoin {
-            id: server.id.clone(),
-            user: user.id.clone(),
-        }
-        .p(server.id.clone())
-        .await;
-
-        EventV1::ServerCreate {
-            id: server.id.clone(),
-            server: server.clone().into(),
-            channels: channels
-                .clone()
-                .into_iter()
-                .map(|channel| channel.into())
-                .collect(),
-            emojis: emojis.into_iter().map(|emoji| emoji.into()).collect(),
-        }
-        .private(user.id.clone())
-        .await;
-
-        if let Some(id) = server
-            .system_messages
-            .as_ref()
-            .and_then(|x| x.user_joined.as_ref())
-        {
-            SystemMessage::UserJoined {
-                id: user.id.clone(),
-            }
-            .into_message(id.to_string())
-            .send_without_notifications(db, false, false)
-            .await
-            .ok();
-        }
-
-        Ok(channels)
-    }
-
-    /// Update member data
-    pub async fn update<'a>(
-        &mut self,
-        db: &Database,
-        partial: PartialMember,
-        remove: Vec<FieldsMember>,
-    ) -> Result<()> {
-        for field in &remove {
-            self.remove_field(field);
-        }
-
-        self.apply_options(partial.clone());
-
-        db.update_member(&self.id, &partial, remove.clone()).await?;
-
-        EventV1::ServerMemberUpdate {
-            id: self.id.clone().into(),
-            data: partial.into(),
-            clear: remove.into_iter().map(|field| field.into()).collect(),
-        }
-        .p(self.id.server.clone())
-        .await;
-
-        Ok(())
-    }
-
-    pub fn remove_field(&mut self, field: &FieldsMember) {
-        match field {
-            FieldsMember::Avatar => self.avatar = None,
-            FieldsMember::Nickname => self.nickname = None,
-            FieldsMember::Roles => self.roles.clear(),
-            FieldsMember::Timeout => self.timeout = None,
-        }
-    }
-
-    /// Get this user's current ranking
-    pub fn get_ranking(&self, server: &Server) -> i64 {
-        let mut value = i64::MAX;
-        for role in &self.roles {
-            if let Some(role) = server.roles.get(role) {
-                if role.rank < value {
-                    value = role.rank;
-                }
-            }
-        }
-
-        value
-    }
-
-    /// Check whether this member is in timeout
-    pub fn in_timeout(&self) -> bool {
-        if let Some(timeout) = self.timeout {
-            *timeout > *Timestamp::now_utc()
-        } else {
-            false
-        }
-    }
-
-    /// Remove member from server
-    pub async fn remove(
-        self,
-        db: &Database,
-        server: &Server,
-        intention: RemovalIntention,
-        silent: bool,
-    ) -> Result<()> {
-        db.delete_member(&self.id).await?;
-
-        EventV1::ServerMemberLeave {
-            id: self.id.server.to_string(),
-            user: self.id.user.to_string(),
-        }
-        .p(self.id.server.to_string())
-        .await;
-
-        if !silent {
-            if let Some(id) = server
-                .system_messages
-                .as_ref()
-                .and_then(|x| match intention {
-                    RemovalIntention::Leave => x.user_left.as_ref(),
-                    RemovalIntention::Kick => x.user_kicked.as_ref(),
-                    RemovalIntention::Ban => x.user_banned.as_ref(),
-                })
-            {
-                match intention {
-                    RemovalIntention::Leave => SystemMessage::UserLeft { id: self.id.user },
-                    RemovalIntention::Kick => SystemMessage::UserKicked { id: self.id.user },
-                    RemovalIntention::Ban => SystemMessage::UserBanned { id: self.id.user },
-                }
-                .into_message(id.to_string())
-                // TODO: support notifications here in the future?
-                .send_without_notifications(db, false, false)
-                .await
-                .ok();
-            }
-        }
-
-        Ok(())
-    }
-}

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

@@ -1,41 +0,0 @@
-use revolt_result::Result;
-
-use crate::{FieldsMember, Member, MemberCompositeKey, PartialMember};
-
-mod mongodb;
-mod reference;
-
-#[async_trait]
-pub trait AbstractServerMembers: Sync + Send {
-    /// Insert a new server member into the database
-    async fn insert_member(&self, member: &Member) -> Result<()>;
-
-    /// Fetch a server member by their id
-    async fn fetch_member(&self, server_id: &str, user_id: &str) -> Result<Member>;
-
-    /// Fetch all members in a server
-    async fn fetch_all_members<'a>(&self, server_id: &str) -> Result<Vec<Member>>;
-
-    /// Fetch all memberships for a user
-    async fn fetch_all_memberships<'a>(&self, user_id: &str) -> Result<Vec<Member>>;
-
-    /// Fetch multiple members by their ids
-    async fn fetch_members<'a>(&self, server_id: &str, ids: &'a [String]) -> Result<Vec<Member>>;
-
-    /// Fetch member count of a server
-    async fn fetch_member_count(&self, server_id: &str) -> Result<usize>;
-
-    /// Fetch server count of a user
-    async fn fetch_server_count(&self, user_id: &str) -> Result<usize>;
-
-    /// Update information for a server member
-    async fn update_member(
-        &self,
-        id: &MemberCompositeKey,
-        partial: &PartialMember,
-        remove: Vec<FieldsMember>,
-    ) -> Result<()>;
-
-    /// Delete a server member by their id
-    async fn delete_member(&self, id: &MemberCompositeKey) -> Result<()>;
-}

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

@@ -1,178 +0,0 @@
-use futures::StreamExt;
-use revolt_result::Result;
-
-use crate::{FieldsMember, Member, MemberCompositeKey, PartialMember};
-use crate::{IntoDocumentPath, MongoDb};
-
-use super::AbstractServerMembers;
-
-static COL: &str = "server_members";
-
-#[async_trait]
-impl AbstractServerMembers for MongoDb {
-    /// Insert a new server member into the database
-    async fn insert_member(&self, member: &Member) -> Result<()> {
-        query!(self, insert_one, COL, &member).map(|_| ())
-    }
-
-    /// Fetch a server member by their id
-    async fn fetch_member(&self, server_id: &str, user_id: &str) -> Result<Member> {
-        query!(
-            self,
-            find_one,
-            COL,
-            doc! {
-                "_id.server": server_id,
-                "_id.user": user_id
-            }
-        )?
-        .ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch all members in a server
-    async fn fetch_all_members<'a>(&self, server_id: &str) -> Result<Vec<Member>> {
-        Ok(self
-            .col::<Member>(COL)
-            .find(
-                doc! {
-                    "_id.server": server_id
-                },
-                None,
-            )
-            .await
-            .map_err(|_| create_database_error!("find", COL))?
-            .filter_map(|s| async {
-                if cfg!(debug_assertions) {
-                    Some(s.unwrap())
-                } else {
-                    s.ok()
-                }
-            })
-            .collect()
-            .await)
-    }
-
-    /// Fetch all memberships for a user
-    async fn fetch_all_memberships<'a>(&self, user_id: &str) -> Result<Vec<Member>> {
-        Ok(self
-            .col::<Member>(COL)
-            .find(
-                doc! {
-                    "_id.user": user_id
-                },
-                None,
-            )
-            .await
-            .map_err(|_| create_database_error!("find", COL))?
-            .filter_map(|s| async {
-                if cfg!(debug_assertions) {
-                    Some(s.unwrap())
-                } else {
-                    s.ok()
-                }
-            })
-            .collect()
-            .await)
-    }
-
-    /// Fetch multiple members by their ids
-    async fn fetch_members<'a>(&self, server_id: &str, ids: &'a [String]) -> Result<Vec<Member>> {
-        Ok(self
-            .col::<Member>(COL)
-            .find(
-                doc! {
-                    "_id.server": server_id,
-                    "_id.user": {
-                        "$in": ids
-                    }
-                },
-                None,
-            )
-            .await
-            .map_err(|_| create_database_error!("find", COL))?
-            .filter_map(|s| async {
-                if cfg!(debug_assertions) {
-                    Some(s.unwrap())
-                } else {
-                    s.ok()
-                }
-            })
-            .collect()
-            .await)
-    }
-
-    /// Fetch member count of a server
-    async fn fetch_member_count(&self, server_id: &str) -> Result<usize> {
-        self.col::<Member>(COL)
-            .count_documents(
-                doc! {
-                    "_id.server": server_id
-                },
-                None,
-            )
-            .await
-            .map(|c| c as usize)
-            .map_err(|_| create_database_error!("count_documents", COL))
-    }
-
-    /// Fetch server count of a user
-    async fn fetch_server_count(&self, user_id: &str) -> Result<usize> {
-        self.col::<Member>(COL)
-            .count_documents(
-                doc! {
-                    "_id.user": user_id
-                },
-                None,
-            )
-            .await
-            .map(|c| c as usize)
-            .map_err(|_| create_database_error!("count_documents", COL))
-    }
-
-    /// Update information for a server member
-    async fn update_member(
-        &self,
-        id: &MemberCompositeKey,
-        partial: &PartialMember,
-        remove: Vec<FieldsMember>,
-    ) -> Result<()> {
-        query!(
-            self,
-            update_one,
-            COL,
-            doc! {
-                "_id.server": &id.server,
-                "_id.user": &id.user
-            },
-            partial,
-            remove.iter().map(|x| x as &dyn IntoDocumentPath).collect(),
-            None
-        )
-        .map(|_| ())
-    }
-
-    /// Delete a server member by their id
-    async fn delete_member(&self, id: &MemberCompositeKey) -> Result<()> {
-        query!(
-            self,
-            delete_one,
-            COL,
-            doc! {
-                "_id.server": &id.server,
-                "_id.user": &id.user
-            }
-        )
-        .map(|_| ())
-    }
-}
-
-impl IntoDocumentPath for FieldsMember {
-    fn as_path(&self) -> Option<&'static str> {
-        Some(match self {
-            FieldsMember::Avatar => "avatar",
-            FieldsMember::Nickname => "nickname",
-            FieldsMember::Roles => "roles",
-            FieldsMember::Timeout => "timeout",
-        })
-    }
-}

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

@@ -1,117 +0,0 @@
-use revolt_result::Result;
-
-use crate::ReferenceDb;
-use crate::{FieldsMember, Member, MemberCompositeKey, PartialMember};
-
-use super::AbstractServerMembers;
-
-#[async_trait]
-impl AbstractServerMembers for ReferenceDb {
-    /// Insert a new server member into the database
-    async fn insert_member(&self, member: &Member) -> Result<()> {
-        let mut server_members = self.server_members.lock().await;
-        if server_members.contains_key(&member.id) {
-            Err(create_database_error!("insert", "member"))
-        } else {
-            server_members.insert(member.id.clone(), member.clone());
-            Ok(())
-        }
-    }
-
-    /// Fetch a server member by their id
-    async fn fetch_member(&self, server_id: &str, user_id: &str) -> Result<Member> {
-        let server_members = self.server_members.lock().await;
-        server_members
-            .get(&MemberCompositeKey {
-                server: server_id.to_string(),
-                user: user_id.to_string(),
-            })
-            .cloned()
-            .ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch all members in a server
-    async fn fetch_all_members<'a>(&self, server_id: &str) -> Result<Vec<Member>> {
-        let server_members = self.server_members.lock().await;
-        Ok(server_members
-            .values()
-            .filter(|member| member.id.server == server_id)
-            .cloned()
-            .collect())
-    }
-
-    /// Fetch all memberships for a user
-    async fn fetch_all_memberships<'a>(&self, user_id: &str) -> Result<Vec<Member>> {
-        let server_members = self.server_members.lock().await;
-        Ok(server_members
-            .values()
-            .filter(|member| member.id.user == user_id)
-            .cloned()
-            .collect())
-    }
-
-    /// Fetch multiple members by their ids
-    async fn fetch_members<'a>(&self, server_id: &str, ids: &'a [String]) -> Result<Vec<Member>> {
-        let server_members = self.server_members.lock().await;
-        ids.iter()
-            .map(|id| {
-                server_members
-                    .get(&MemberCompositeKey {
-                        server: server_id.to_string(),
-                        user: id.to_string(),
-                    })
-                    .cloned()
-                    .ok_or_else(|| create_error!(NotFound))
-            })
-            .collect()
-    }
-
-    /// Fetch member count of a server
-    async fn fetch_member_count(&self, server_id: &str) -> Result<usize> {
-        let server_members = self.server_members.lock().await;
-        Ok(server_members
-            .values()
-            .filter(|member| member.id.server == server_id)
-            .count())
-    }
-
-    /// Fetch server count of a user
-    async fn fetch_server_count(&self, user_id: &str) -> Result<usize> {
-        let server_members = self.server_members.lock().await;
-        Ok(server_members
-            .values()
-            .filter(|member| member.id.user == user_id)
-            .count())
-    }
-
-    /// Update information for a server member
-    async fn update_member(
-        &self,
-        id: &MemberCompositeKey,
-        partial: &PartialMember,
-        remove: Vec<FieldsMember>,
-    ) -> Result<()> {
-        let mut server_members = self.server_members.lock().await;
-        if let Some(member) = server_members.get_mut(id) {
-            for field in remove {
-                #[allow(clippy::disallowed_methods)]
-                member.remove_field(&field);
-            }
-
-            member.apply_options(partial.clone());
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Delete a server member by their id
-    async fn delete_member(&self, id: &MemberCompositeKey) -> Result<()> {
-        let mut server_members = self.server_members.lock().await;
-        if server_members.remove(id).is_some() {
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-}

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

@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;

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

@@ -1,392 +0,0 @@
-use std::collections::{HashMap, HashSet};
-
-use revolt_models::v0::{self, DataCreateServerChannel};
-use revolt_permissions::{OverrideField, DEFAULT_PERMISSION_SERVER};
-use revolt_result::Result;
-use ulid::Ulid;
-
-use crate::{events::client::EventV1, Channel, Database, File, User};
-
-auto_derived_partial!(
-    /// Server
-    pub struct Server {
-        /// Unique Id
-        #[serde(rename = "_id")]
-        pub id: String,
-        /// User id of the owner
-        pub owner: String,
-
-        /// Name of the server
-        pub name: String,
-        /// Description for the server
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub description: Option<String>,
-
-        /// Channels within this server
-        // TODO: investigate if this is redundant and can be removed
-        pub channels: Vec<String>,
-        /// Categories for this server
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub categories: Option<Vec<Category>>,
-        /// Configuration for sending system event messages
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub system_messages: Option<SystemMessageChannels>,
-
-        /// Roles for this server
-        #[serde(
-            default = "HashMap::<String, Role>::new",
-            skip_serializing_if = "HashMap::<String, Role>::is_empty"
-        )]
-        pub roles: HashMap<String, Role>,
-        /// Default set of server and channel permissions
-        pub default_permissions: i64,
-
-        /// Icon attachment
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub icon: Option<File>,
-        /// Banner attachment
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub banner: Option<File>,
-
-        /// Bitfield of server flags
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub flags: Option<i32>,
-
-        /// Whether this server is flagged as not safe for work
-        #[serde(skip_serializing_if = "crate::if_false", default)]
-        pub nsfw: bool,
-        /// Whether to enable analytics
-        #[serde(skip_serializing_if = "crate::if_false", default)]
-        pub analytics: bool,
-        /// Whether this server should be publicly discoverable
-        #[serde(skip_serializing_if = "crate::if_false", default)]
-        pub discoverable: bool,
-    },
-    "PartialServer"
-);
-
-auto_derived_partial!(
-    /// Role
-    pub struct Role {
-        /// Role name
-        pub name: String,
-        /// Permissions available to this role
-        pub permissions: OverrideField,
-        /// Colour used for this role
-        ///
-        /// This can be any valid CSS colour
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub colour: Option<String>,
-        /// Whether this role should be shown separately on the member sidebar
-        #[serde(skip_serializing_if = "crate::if_false", default)]
-        pub hoist: bool,
-        /// Ranking of this role
-        #[serde(default)]
-        pub rank: i64,
-    },
-    "PartialRole"
-);
-
-auto_derived!(
-    /// Channel category
-    pub struct Category {
-        /// Unique ID for this category
-        pub id: String,
-        /// Title for this category
-        pub title: String,
-        /// Channels in this category
-        pub channels: Vec<String>,
-    }
-
-    /// System message channel assignments
-    pub struct SystemMessageChannels {
-        /// ID of channel to send user join messages in
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub user_joined: Option<String>,
-        /// ID of channel to send user left messages in
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub user_left: Option<String>,
-        /// ID of channel to send user kicked messages in
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub user_kicked: Option<String>,
-        /// ID of channel to send user banned messages in
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub user_banned: Option<String>,
-    }
-
-    /// Optional fields on server object
-    pub enum FieldsServer {
-        Description,
-        Categories,
-        SystemMessages,
-        Icon,
-        Banner,
-    }
-
-    /// Optional fields on server object
-    pub enum FieldsRole {
-        Colour,
-    }
-);
-
-#[allow(clippy::disallowed_methods)]
-impl Server {
-    /// Create a server
-    pub async fn create(
-        db: &Database,
-        data: v0::DataCreateServer,
-        owner: &User,
-        create_default_channels: bool,
-    ) -> Result<(Server, Vec<Channel>)> {
-        let mut server = Server {
-            id: ulid::Ulid::new().to_string(),
-            owner: owner.id.to_string(),
-            name: data.name,
-            description: data.description,
-            channels: vec![],
-            nsfw: data.nsfw.unwrap_or(false),
-            default_permissions: *DEFAULT_PERMISSION_SERVER as i64,
-
-            analytics: false,
-            banner: None,
-            categories: None,
-            discoverable: false,
-            flags: None,
-            icon: None,
-            roles: HashMap::new(),
-            system_messages: None,
-        };
-
-        let channels: Vec<Channel> = if create_default_channels {
-            vec![
-                Channel::create_server_channel(
-                    db,
-                    &mut server,
-                    DataCreateServerChannel {
-                        channel_type: v0::LegacyServerChannelType::Text,
-                        name: "General".to_string(),
-                        ..Default::default()
-                    },
-                    false,
-                )
-                .await?,
-            ]
-        } else {
-            vec![]
-        };
-
-        server.channels = channels.iter().map(|c| c.id()).collect();
-        db.insert_server(&server).await?;
-        Ok((server, channels))
-    }
-
-    /// Update server data
-    pub async fn update<'a>(
-        &mut self,
-        db: &Database,
-        partial: PartialServer,
-        remove: Vec<FieldsServer>,
-    ) -> Result<()> {
-        for field in &remove {
-            self.remove_field(field);
-        }
-
-        self.apply_options(partial.clone());
-
-        db.update_server(&self.id, &partial, remove.clone()).await?;
-
-        EventV1::ServerUpdate {
-            id: self.id.clone(),
-            data: partial.into(),
-            clear: remove.into_iter().map(|v| v.into()).collect(),
-        }
-        .p(self.id.clone())
-        .await;
-
-        Ok(())
-    }
-
-    /// Delete a server
-    pub async fn delete(self, db: &Database) -> Result<()> {
-        EventV1::ServerDelete {
-            id: self.id.clone(),
-        }
-        .p(self.id.clone())
-        .await;
-
-        db.delete_server(&self.id).await
-    }
-
-    /// Remove a field from Server
-    pub fn remove_field(&mut self, field: &FieldsServer) {
-        match field {
-            FieldsServer::Description => self.description = None,
-            FieldsServer::Categories => self.categories = None,
-            FieldsServer::SystemMessages => self.system_messages = None,
-            FieldsServer::Icon => self.icon = None,
-            FieldsServer::Banner => self.banner = None,
-        }
-    }
-
-    /// Set role permission on a server
-    pub async fn set_role_permission(
-        &mut self,
-        db: &Database,
-        role_id: &str,
-        permissions: OverrideField,
-    ) -> Result<()> {
-        if let Some(role) = self.roles.get_mut(role_id) {
-            role.update(
-                db,
-                &self.id,
-                role_id,
-                PartialRole {
-                    permissions: Some(permissions),
-                    ..Default::default()
-                },
-                vec![],
-            )
-            .await?;
-
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-}
-
-impl Role {
-    /// Into optional struct
-    pub fn into_optional(self) -> PartialRole {
-        PartialRole {
-            name: Some(self.name),
-            permissions: Some(self.permissions),
-            colour: self.colour,
-            hoist: Some(self.hoist),
-            rank: Some(self.rank),
-        }
-    }
-
-    /// Create a role
-    pub async fn create(&self, db: &Database, server_id: &str) -> Result<String> {
-        let role_id = Ulid::new().to_string();
-        db.insert_role(server_id, &role_id, self).await?;
-
-        EventV1::ServerRoleUpdate {
-            id: server_id.to_string(),
-            role_id: role_id.to_string(),
-            data: self.clone().into_optional().into(),
-            clear: vec![],
-        }
-        .p(server_id.to_string())
-        .await;
-
-        Ok(role_id)
-    }
-
-    /// Update server data
-    pub async fn update<'a>(
-        &mut self,
-        db: &Database,
-        server_id: &str,
-        role_id: &str,
-        partial: PartialRole,
-        remove: Vec<FieldsRole>,
-    ) -> Result<()> {
-        for field in &remove {
-            self.remove_field(field);
-        }
-
-        self.apply_options(partial.clone());
-
-        db.update_role(server_id, role_id, &partial, remove.clone())
-            .await?;
-
-        EventV1::ServerRoleUpdate {
-            id: server_id.to_string(),
-            role_id: role_id.to_string(),
-            data: partial.into(),
-            clear: vec![],
-        }
-        .p(server_id.to_string())
-        .await;
-
-        Ok(())
-    }
-
-    /// Remove field from Role
-    pub fn remove_field(&mut self, field: &FieldsRole) {
-        match field {
-            FieldsRole::Colour => self.colour = None,
-        }
-    }
-
-    /// Delete a role
-    pub async fn delete(self, db: &Database, server_id: &str, role_id: &str) -> Result<()> {
-        EventV1::ServerRoleDelete {
-            id: server_id.to_string(),
-            role_id: role_id.to_string(),
-        }
-        .p(server_id.to_string())
-        .await;
-
-        db.delete_role(server_id, role_id).await
-    }
-}
-
-impl SystemMessageChannels {
-    pub fn into_channel_ids(self) -> HashSet<String> {
-        let mut ids = HashSet::new();
-
-        if let Some(id) = self.user_joined {
-            ids.insert(id);
-        }
-
-        if let Some(id) = self.user_left {
-            ids.insert(id);
-        }
-
-        if let Some(id) = self.user_kicked {
-            ids.insert(id);
-        }
-
-        if let Some(id) = self.user_banned {
-            ids.insert(id);
-        }
-
-        ids
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use revolt_permissions::{calculate_server_permissions, ChannelPermission};
-
-    use crate::{fixture, util::permissions::DatabasePermissionQuery};
-
-    #[async_std::test]
-    async fn permissions() {
-        database_test!(|db| async move {
-            fixture!(db, "server_with_roles",
-                owner user 0
-                moderator user 1
-                user user 2
-                server server 4);
-
-            let mut query = DatabasePermissionQuery::new(&db, &owner).server(&server);
-            assert!(calculate_server_permissions(&mut query)
-                .await
-                .has_channel_permission(ChannelPermission::GrantAllSafe));
-
-            let mut query = DatabasePermissionQuery::new(&db, &moderator).server(&server);
-            assert!(calculate_server_permissions(&mut query)
-                .await
-                .has_channel_permission(ChannelPermission::BanMembers));
-
-            let mut query = DatabasePermissionQuery::new(&db, &user).server(&server);
-            assert!(!calculate_server_permissions(&mut query)
-                .await
-                .has_channel_permission(ChannelPermission::BanMembers));
-        });
-    }
-}

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

@@ -1,126 +0,0 @@
-use revolt_result::Result;
-
-use crate::ReferenceDb;
-use crate::{FieldsRole, FieldsServer, PartialRole, PartialServer, Role, Server};
-
-use super::AbstractServers;
-
-#[async_trait]
-impl AbstractServers for ReferenceDb {
-    /// Insert a new server into database
-    async fn insert_server(&self, server: &Server) -> Result<()> {
-        let mut servers = self.servers.lock().await;
-        if servers.contains_key(&server.id) {
-            Err(create_database_error!("insert", "server"))
-        } else {
-            servers.insert(server.id.to_string(), server.clone());
-            Ok(())
-        }
-    }
-
-    /// Fetch a server by its id
-    async fn fetch_server(&self, id: &str) -> Result<Server> {
-        let servers = self.servers.lock().await;
-        servers
-            .get(id)
-            .cloned()
-            .ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch a servers by their ids
-    async fn fetch_servers<'a>(&self, ids: &'a [String]) -> Result<Vec<Server>> {
-        let servers = self.servers.lock().await;
-        ids.iter()
-            .map(|id| {
-                servers
-                    .get(id)
-                    .cloned()
-                    .ok_or_else(|| create_error!(NotFound))
-            })
-            .collect()
-    }
-
-    /// Update a server with new information
-    async fn update_server(
-        &self,
-        id: &str,
-        partial: &PartialServer,
-        remove: Vec<FieldsServer>,
-    ) -> Result<()> {
-        let mut servers = self.servers.lock().await;
-        if let Some(server) = servers.get_mut(id) {
-            for field in remove {
-                #[allow(clippy::disallowed_methods)]
-                server.remove_field(&field);
-            }
-
-            server.apply_options(partial.clone());
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Delete a server by its id
-    async fn delete_server(&self, id: &str) -> Result<()> {
-        let mut servers = self.servers.lock().await;
-        if servers.remove(id).is_some() {
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Insert a new role into server object
-    async fn insert_role(&self, server_id: &str, role_id: &str, role: &Role) -> Result<()> {
-        let mut servers = self.servers.lock().await;
-        if let Some(server) = servers.get_mut(server_id) {
-            server.roles.insert(role_id.to_string(), role.clone());
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Update an existing role on a server
-    async fn update_role(
-        &self,
-        server_id: &str,
-        role_id: &str,
-        partial: &PartialRole,
-        remove: Vec<FieldsRole>,
-    ) -> Result<()> {
-        let mut servers = self.servers.lock().await;
-        if let Some(server) = servers.get_mut(server_id) {
-            if let Some(role) = server.roles.get_mut(role_id) {
-                for field in remove {
-                    #[allow(clippy::disallowed_methods)]
-                    role.remove_field(&field);
-                }
-
-                role.apply_options(partial.clone());
-                Ok(())
-            } else {
-                Err(create_error!(NotFound))
-            }
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Delete a role from a server
-    ///
-    /// Also updates channels and members.
-    async fn delete_role(&self, server_id: &str, role_id: &str) -> Result<()> {
-        let mut servers = self.servers.lock().await;
-        if let Some(server) = servers.get_mut(server_id) {
-            if server.roles.remove(role_id).is_some() {
-                Ok(())
-            } else {
-                Err(create_error!(NotFound))
-            }
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-}

crates/core/database/src/models/user_settings/mod.rs

@@ -1,5 +0,0 @@
-mod model;
-mod ops;
-
-pub use model::*;
-pub use ops::*;

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

@@ -1,46 +0,0 @@
-use revolt_result::Result;
-
-use crate::ReferenceDb;
-use crate::UserSettings;
-
-use super::AbstractUserSettings;
-
-#[async_trait]
-impl AbstractUserSettings for ReferenceDb {
-    /// Fetch a subset of user settings
-    async fn fetch_user_settings(&'_ self, id: &str, filter: &'_ [String]) -> Result<UserSettings> {
-        let user_settings = self.user_settings.lock().await;
-        user_settings
-            .get(id)
-            .cloned()
-            .map(|settings| {
-                settings
-                    .into_iter()
-                    .filter(|(key, _)| filter.contains(key))
-                    .collect()
-            })
-            .ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Update a subset of user settings
-    async fn set_user_settings(&self, id: &str, settings: &UserSettings) -> Result<()> {
-        let mut user_settings = self.user_settings.lock().await;
-        if let Some(settings) = user_settings.get_mut(id) {
-            settings.extend(settings.clone());
-        } else {
-            user_settings.insert(id.to_string(), settings.clone());
-        }
-
-        Ok(())
-    }
-
-    /// Delete all user settings
-    async fn delete_user_settings(&self, id: &str) -> Result<()> {
-        let mut user_settings = self.user_settings.lock().await;
-        if user_settings.remove(id).is_some() {
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-}

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

@@ -1,13 +0,0 @@
-mod model;
-mod ops;
-#[cfg(feature = "rocket-impl")]
-mod rocket;
-#[cfg(feature = "rocket-impl")]
-mod schema;
-
-#[cfg(feature = "rocket-impl")]
-pub use self::rocket::*;
-#[cfg(feature = "rocket-impl")]
-pub use self::schema::*;
-pub use model::*;
-pub use ops::*;

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

@@ -1,642 +0,0 @@
-use std::{collections::HashSet, time::Duration};
-
-use crate::{events::client::EventV1, Database, File, RatelimitEvent};
-
-use once_cell::sync::Lazy;
-use rand::seq::SliceRandom;
-use revolt_config::config;
-use revolt_models::v0;
-use revolt_presence::filter_online;
-use revolt_result::{create_error, Result};
-use ulid::Ulid;
-
-auto_derived_partial!(
-    /// # User
-    pub struct User {
-        /// Unique Id
-        #[serde(rename = "_id")]
-        pub id: String,
-        /// Username
-        pub username: String,
-        /// Discriminator
-        pub discriminator: String,
-        /// Display name
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub display_name: Option<String>,
-        #[serde(skip_serializing_if = "Option::is_none")]
-        /// Avatar attachment
-        pub avatar: Option<File>,
-        /// Relationships with other users
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub relations: Option<Vec<Relationship>>,
-
-        /// Bitfield of user badges
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub badges: Option<i32>,
-        /// User's current status
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub status: Option<UserStatus>,
-        /// User's profile page
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub profile: Option<UserProfile>,
-
-        /// Enum of user flags
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub flags: Option<i32>,
-        /// Whether this user is privileged
-        #[serde(skip_serializing_if = "crate::if_false", default)]
-        pub privileged: bool,
-        /// Bot information
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub bot: Option<BotInformation>,
-    },
-    "PartialUser"
-);
-
-auto_derived!(
-    /// Optional fields on user object
-    pub enum FieldsUser {
-        Avatar,
-        StatusText,
-        StatusPresence,
-        ProfileContent,
-        ProfileBackground,
-    }
-
-    /// User's relationship with another user (or themselves)
-    pub enum RelationshipStatus {
-        None,
-        User,
-        Friend,
-        Outgoing,
-        Incoming,
-        Blocked,
-        BlockedOther,
-    }
-
-    /// Relationship entry indicating current status with other user
-    pub struct Relationship {
-        #[serde(rename = "_id")]
-        pub id: String,
-        pub status: RelationshipStatus,
-    }
-
-    /// Presence status
-    pub enum Presence {
-        /// User is online
-        Online,
-        /// User is not currently available
-        Idle,
-        /// User is focusing / will only receive mentions
-        Focus,
-        /// User is busy / will not receive any notifications
-        Busy,
-        /// User appears to be offline
-        Invisible,
-    }
-
-    /// User's active status
-    #[derive(Default)]
-    pub struct UserStatus {
-        /// Custom status text
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub text: Option<String>,
-        /// Current presence option
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub presence: Option<Presence>,
-    }
-
-    /// User's profile
-    #[derive(Default)]
-    pub struct UserProfile {
-        /// Text content on user's profile
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub content: Option<String>,
-        /// Background visible on user's profile
-        #[serde(skip_serializing_if = "Option::is_none")]
-        pub background: Option<File>,
-    }
-
-    /// Bot information for if the user is a bot
-    pub struct BotInformation {
-        /// Id of the owner of this bot
-        pub owner: String,
-    }
-
-    /// Enumeration providing a hint to the type of user we are handling
-    pub enum UserHint {
-        /// Could be either a user or a bot
-        Any,
-        /// Only match bots
-        Bot,
-        /// Only match users
-        User,
-    }
-);
-
-pub static DISCRIMINATOR_SEARCH_SPACE: Lazy<HashSet<String>> = Lazy::new(|| {
-    let mut set = (2..9999)
-        .map(|v| format!("{:0>4}", v))
-        .collect::<HashSet<String>>();
-
-    for discrim in [
-        123, 1234, 1111, 2222, 3333, 4444, 5555, 6666, 7777, 8888, 9999,
-    ] {
-        set.remove(&format!("{:0>4}", discrim));
-    }
-
-    set.into_iter().collect()
-});
-
-#[allow(clippy::derivable_impls)]
-impl Default for User {
-    fn default() -> Self {
-        Self {
-            id: Default::default(),
-            username: Default::default(),
-            discriminator: Default::default(),
-            display_name: Default::default(),
-            avatar: Default::default(),
-            relations: Default::default(),
-            badges: Default::default(),
-            status: Default::default(),
-            profile: Default::default(),
-            flags: Default::default(),
-            privileged: Default::default(),
-            bot: Default::default(),
-        }
-    }
-}
-
-#[allow(clippy::disallowed_methods)]
-impl User {
-    /// Create a new user
-    pub async fn create<I, D>(
-        db: &Database,
-        username: String,
-        account_id: I,
-        data: D,
-    ) -> Result<User>
-    where
-        I: Into<Option<String>>,
-        D: Into<Option<PartialUser>>,
-    {
-        let username = User::validate_username(username)?;
-        let mut user = User {
-            id: account_id.into().unwrap_or_else(|| Ulid::new().to_string()),
-            discriminator: User::find_discriminator(db, &username, None).await?,
-            username,
-            ..Default::default()
-        };
-
-        if let Some(data) = data.into() {
-            user.apply_options(data);
-        }
-
-        db.insert_user(&user).await?;
-        Ok(user)
-    }
-
-    /// Get the relationship with another user
-    pub fn relationship_with(&self, user_b: &str) -> RelationshipStatus {
-        if self.id == user_b {
-            return RelationshipStatus::User;
-        }
-
-        if let Some(relations) = &self.relations {
-            if let Some(relationship) = relations.iter().find(|x| x.id == user_b) {
-                return relationship.status.clone();
-            }
-        }
-
-        RelationshipStatus::None
-    }
-
-    pub fn is_friends_with(&self, user_b: &str) -> bool {
-        matches!(
-            self.relationship_with(user_b),
-            RelationshipStatus::Friend | RelationshipStatus::User
-        )
-    }
-
-    /// Check whether two users have a mutual connection
-    ///
-    /// This will check if user and user_b share a server or a group.
-    pub async fn has_mutual_connection(&self, db: &Database, user_b: &str) -> Result<bool> {
-        Ok(!db
-            .fetch_mutual_server_ids(&self.id, user_b)
-            .await?
-            .is_empty()
-            || !db
-                .fetch_mutual_channel_ids(&self.id, user_b)
-                .await?
-                .is_empty())
-    }
-
-    /// Check if this user can acquire another server
-    pub async fn can_acquire_server(&self, db: &Database) -> Result<()> {
-        let config = config().await;
-        if db.fetch_server_count(&self.id).await? <= config.features.limits.default.servers {
-            Ok(())
-        } else {
-            Err(create_error!(TooManyServers {
-                max: config.features.limits.default.servers
-            }))
-        }
-    }
-
-    /// Sanitise and validate a username can be used
-    pub fn validate_username(username: String) -> Result<String> {
-        // Copy the username for validation
-        let username_lowercase = username.to_lowercase();
-
-        // Block homoglyphs
-        if decancer::cure(&username_lowercase).into_str() != username_lowercase {
-            return Err(create_error!(InvalidUsername));
-        }
-
-        // Ensure the username itself isn't blocked
-        const BLOCKED_USERNAMES: &[&str] = &["admin", "revolt"];
-
-        for username in BLOCKED_USERNAMES {
-            if username_lowercase == *username {
-                return Err(create_error!(InvalidUsername));
-            }
-        }
-
-        // Ensure none of the following substrings show up in the username
-        const BLOCKED_SUBSTRINGS: &[&str] = &["```"];
-
-        for substr in BLOCKED_SUBSTRINGS {
-            if username_lowercase.contains(substr) {
-                return Err(create_error!(InvalidUsername));
-            }
-        }
-
-        Ok(username)
-    }
-
-    /// Find a user from a given token and hint
-    #[async_recursion]
-    pub async fn from_token(db: &Database, token: &str, hint: UserHint) -> Result<User> {
-        match hint {
-            UserHint::Bot => {
-                db.fetch_user(
-                    &db.fetch_bot_by_token(token)
-                        .await
-                        .map_err(|_| create_error!(InternalError))?
-                        .id,
-                )
-                .await
-            }
-            UserHint::User => db.fetch_user_by_token(token).await,
-            UserHint::Any => {
-                if let Ok(user) = User::from_token(db, token, UserHint::User).await {
-                    Ok(user)
-                } else {
-                    User::from_token(db, token, UserHint::Bot).await
-                }
-            }
-        }
-    }
-
-    /// Helper function to fetch many users as a mutually connected user
-    /// (while optimising the online ID query)
-    pub async fn fetch_many_ids_as_mutuals(
-        db: &Database,
-        perspective: &User,
-        ids: &[String],
-    ) -> Result<Vec<v0::User>> {
-        let online_ids = filter_online(ids).await;
-
-        Ok(db
-            .fetch_users(ids)
-            .await?
-            .into_iter()
-            .map(|user| {
-                let is_online = online_ids.contains(&user.id);
-                user.into_known(perspective, is_online)
-            })
-            .collect())
-    }
-
-    /// Find a free discriminator for a given username
-    pub async fn find_discriminator(
-        db: &Database,
-        username: &str,
-        preferred: Option<(String, String)>,
-    ) -> Result<String> {
-        let search_space: &HashSet<String> = &DISCRIMINATOR_SEARCH_SPACE;
-        let used_discriminators: HashSet<String> = db
-            .fetch_discriminators_in_use(username)
-            .await?
-            .into_iter()
-            .collect();
-
-        let available_discriminators: Vec<&String> =
-            search_space.difference(&used_discriminators).collect();
-
-        if available_discriminators.is_empty() {
-            return Err(create_error!(UsernameTaken));
-        }
-
-        if let Some((preferred, target_id)) = preferred {
-            if available_discriminators.contains(&&preferred) {
-                return Ok(preferred);
-            } else {
-                if db
-                    .has_ratelimited(
-                        &target_id,
-                        crate::RatelimitEventType::DiscriminatorChange,
-                        Duration::from_secs(60 * 60 * 24),
-                        1,
-                    )
-                    .await?
-                {
-                    return Err(create_error!(DiscriminatorChangeRatelimited));
-                }
-
-                RatelimitEvent::create(
-                    db,
-                    target_id,
-                    crate::RatelimitEventType::DiscriminatorChange,
-                )
-                .await?;
-            }
-        }
-
-        let mut rng = rand::thread_rng();
-        Ok(available_discriminators
-            .choose(&mut rng)
-            .expect("we can assert this has an element")
-            .to_string())
-    }
-
-    /// Update a user's username
-    pub async fn update_username(&mut self, db: &Database, username: String) -> Result<()> {
-        let username = User::validate_username(username)?;
-        if self.username.to_lowercase() == username.to_lowercase() {
-            self.update(
-                db,
-                PartialUser {
-                    username: Some(username),
-                    ..Default::default()
-                },
-                vec![],
-            )
-            .await
-        } else {
-            self.update(
-                db,
-                PartialUser {
-                    discriminator: Some(
-                        User::find_discriminator(
-                            db,
-                            &username,
-                            Some((self.discriminator.to_string(), self.id.clone())),
-                        )
-                        .await?,
-                    ),
-                    username: Some(username),
-                    ..Default::default()
-                },
-                vec![],
-            )
-            .await
-        }
-    }
-
-    /// Set a relationship to another user
-    pub async fn set_relationship(
-        &mut self,
-        db: &Database,
-        user_b: &User,
-        status: RelationshipStatus,
-    ) -> Result<()> {
-        db.set_relationship(&self.id, &user_b.id, &status).await?;
-
-        if let RelationshipStatus::None | RelationshipStatus::User = status {
-            if let Some(relations) = &mut self.relations {
-                relations.retain(|relation| relation.id != user_b.id);
-            }
-        } else {
-            let relation = Relationship {
-                id: user_b.id.to_string(),
-                status,
-            };
-
-            if let Some(relations) = &mut self.relations {
-                relations.retain(|relation| relation.id != user_b.id);
-                relations.push(relation);
-            } else {
-                self.relations = Some(vec![relation]);
-            }
-        }
-
-        Ok(())
-    }
-
-    /// Apply a certain relationship between two users
-    pub async fn apply_relationship(
-        &mut self,
-        db: &Database,
-        target: &mut User,
-        local: RelationshipStatus,
-        remote: RelationshipStatus,
-    ) -> Result<()> {
-        target.set_relationship(db, self, remote).await?;
-        self.set_relationship(db, target, local).await?;
-
-        EventV1::UserRelationship {
-            id: target.id.clone(),
-            user: self.clone().into(db, Some(&*target)).await,
-        }
-        .private(target.id.clone())
-        .await;
-
-        EventV1::UserRelationship {
-            id: self.id.clone(),
-            user: target.clone().into(db, Some(&*self)).await,
-        }
-        .private(self.id.clone())
-        .await;
-
-        Ok(())
-    }
-
-    /// Add another user as a friend
-    pub async fn add_friend(&mut self, db: &Database, target: &mut User) -> Result<()> {
-        match self.relationship_with(&target.id) {
-            RelationshipStatus::User => Err(create_error!(NoEffect)),
-            RelationshipStatus::Friend => Err(create_error!(AlreadyFriends)),
-            RelationshipStatus::Outgoing => Err(create_error!(AlreadySentRequest)),
-            RelationshipStatus::Blocked => Err(create_error!(Blocked)),
-            RelationshipStatus::BlockedOther => Err(create_error!(BlockedByOther)),
-            RelationshipStatus::Incoming => {
-                self.apply_relationship(
-                    db,
-                    target,
-                    RelationshipStatus::Friend,
-                    RelationshipStatus::Friend,
-                )
-                .await
-            }
-            RelationshipStatus::None => {
-                self.apply_relationship(
-                    db,
-                    target,
-                    RelationshipStatus::Outgoing,
-                    RelationshipStatus::Incoming,
-                )
-                .await
-            }
-        }
-    }
-
-    /// Remove another user as a friend
-    pub async fn remove_friend(&mut self, db: &Database, target: &mut User) -> Result<()> {
-        match self.relationship_with(&target.id) {
-            RelationshipStatus::Friend
-            | RelationshipStatus::Outgoing
-            | RelationshipStatus::Incoming => {
-                self.apply_relationship(
-                    db,
-                    target,
-                    RelationshipStatus::None,
-                    RelationshipStatus::None,
-                )
-                .await
-            }
-            _ => Err(create_error!(NoEffect)),
-        }
-    }
-
-    /// Block another user
-    pub async fn block_user(&mut self, db: &Database, target: &mut User) -> Result<()> {
-        match self.relationship_with(&target.id) {
-            RelationshipStatus::User | RelationshipStatus::Blocked => Err(create_error!(NoEffect)),
-            RelationshipStatus::BlockedOther => {
-                self.apply_relationship(
-                    db,
-                    target,
-                    RelationshipStatus::Blocked,
-                    RelationshipStatus::Blocked,
-                )
-                .await
-            }
-            RelationshipStatus::None
-            | RelationshipStatus::Friend
-            | RelationshipStatus::Incoming
-            | RelationshipStatus::Outgoing => {
-                self.apply_relationship(
-                    db,
-                    target,
-                    RelationshipStatus::Blocked,
-                    RelationshipStatus::BlockedOther,
-                )
-                .await
-            }
-        }
-    }
-
-    /// Unblock another user
-    pub async fn unblock_user(&mut self, db: &Database, target: &mut User) -> Result<()> {
-        match self.relationship_with(&target.id) {
-            RelationshipStatus::Blocked => match target.relationship_with(&self.id) {
-                RelationshipStatus::Blocked => {
-                    self.apply_relationship(
-                        db,
-                        target,
-                        RelationshipStatus::BlockedOther,
-                        RelationshipStatus::Blocked,
-                    )
-                    .await
-                }
-                RelationshipStatus::BlockedOther => {
-                    self.apply_relationship(
-                        db,
-                        target,
-                        RelationshipStatus::None,
-                        RelationshipStatus::None,
-                    )
-                    .await
-                }
-                _ => Err(create_error!(InternalError)),
-            },
-            _ => Err(create_error!(NoEffect)),
-        }
-    }
-
-    /// Update user data
-    pub async fn update<'a>(
-        &mut self,
-        db: &Database,
-        partial: PartialUser,
-        remove: Vec<FieldsUser>,
-    ) -> Result<()> {
-        for field in &remove {
-            self.remove_field(field);
-        }
-
-        self.apply_options(partial.clone());
-        db.update_user(&self.id, &partial, remove.clone()).await?;
-
-        EventV1::UserUpdate {
-            id: self.id.clone(),
-            data: partial.into(),
-            clear: remove.into_iter().map(|v| v.into()).collect(),
-            event_id: Some(Ulid::new().to_string()),
-        }
-        .p_user(self.id.clone(), db)
-        .await;
-
-        Ok(())
-    }
-
-    /// Remove a field from User object
-    pub fn remove_field(&mut self, field: &FieldsUser) {
-        match field {
-            FieldsUser::Avatar => self.avatar = None,
-            FieldsUser::StatusText => {
-                if let Some(x) = self.status.as_mut() {
-                    x.text = None;
-                }
-            }
-            FieldsUser::StatusPresence => {
-                if let Some(x) = self.status.as_mut() {
-                    x.presence = None;
-                }
-            }
-            FieldsUser::ProfileContent => {
-                if let Some(x) = self.profile.as_mut() {
-                    x.content = None;
-                }
-            }
-            FieldsUser::ProfileBackground => {
-                if let Some(x) = self.profile.as_mut() {
-                    x.background = None;
-                }
-            }
-        }
-    }
-
-    /// Mark as deleted
-    pub async fn mark_deleted(&mut self, db: &Database) -> Result<()> {
-        self.update(
-            db,
-            PartialUser {
-                username: Some(format!("Deleted User {}", self.id)),
-                flags: Some(2),
-                ..Default::default()
-            },
-            vec![
-                FieldsUser::Avatar,
-                FieldsUser::StatusText,
-                FieldsUser::StatusPresence,
-                FieldsUser::ProfileContent,
-                FieldsUser::ProfileBackground,
-            ],
-        )
-        .await
-    }
-}

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

@@ -1,165 +0,0 @@
-use revolt_result::Result;
-
-use crate::{FieldsUser, PartialUser, RelationshipStatus, User};
-use crate::{ReferenceDb, Relationship};
-
-use super::AbstractUsers;
-
-#[async_trait]
-impl AbstractUsers for ReferenceDb {
-    /// Insert a new user into the database
-    async fn insert_user(&self, user: &User) -> Result<()> {
-        let mut users = self.users.lock().await;
-        if users.contains_key(&user.id) {
-            Err(create_database_error!("insert", "user"))
-        } else {
-            users.insert(user.id.to_string(), user.clone());
-            Ok(())
-        }
-    }
-
-    /// Fetch a user from the database
-    async fn fetch_user(&self, id: &str) -> Result<User> {
-        let users = self.users.lock().await;
-        users
-            .get(id)
-            .cloned()
-            .ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch a user from the database by their username
-    async fn fetch_user_by_username(&self, username: &str, discriminator: &str) -> Result<User> {
-        let users = self.users.lock().await;
-        let lowercase = username.to_lowercase();
-        users
-            .values()
-            .find(|user| {
-                user.username.to_lowercase() == lowercase && user.discriminator == discriminator
-            })
-            .cloned()
-            .ok_or_else(|| create_error!(NotFound))
-    }
-
-    /// Fetch a user from the database by their session token
-    async fn fetch_user_by_token(&self, _token: &str) -> Result<User> {
-        todo!()
-    }
-
-    /// Fetch multiple users by their ids
-    async fn fetch_users<'a>(&self, ids: &'a [String]) -> Result<Vec<User>> {
-        let users = self.users.lock().await;
-        ids.iter()
-            .map(|id| {
-                users
-                    .get(id)
-                    .cloned()
-                    .ok_or_else(|| create_error!(NotFound))
-            })
-            .collect()
-    }
-
-    /// Fetch all discriminators in use for a username
-    async fn fetch_discriminators_in_use(&self, username: &str) -> Result<Vec<String>> {
-        let users = self.users.lock().await;
-        let lowercase = username.to_lowercase();
-        Ok(users
-            .values()
-            .filter(|user| user.username.to_lowercase() == lowercase)
-            .map(|user| &user.discriminator)
-            .cloned()
-            .collect())
-    }
-
-    /// Fetch ids of users that both users are friends with
-    async fn fetch_mutual_user_ids(&self, _user_a: &str, _user_b: &str) -> Result<Vec<String>> {
-        todo!()
-    }
-
-    /// Fetch ids of channels that both users are in
-    async fn fetch_mutual_channel_ids(&self, _user_a: &str, _user_b: &str) -> Result<Vec<String>> {
-        todo!()
-    }
-
-    /// Fetch ids of servers that both users share
-    async fn fetch_mutual_server_ids(&self, _user_a: &str, _user_b: &str) -> Result<Vec<String>> {
-        todo!()
-    }
-
-    /// Update a user by their id given some data
-    async fn update_user(
-        &self,
-        id: &str,
-        partial: &PartialUser,
-        remove: Vec<FieldsUser>,
-    ) -> Result<()> {
-        let mut users = self.users.lock().await;
-        if let Some(user) = users.get_mut(id) {
-            for field in remove {
-                #[allow(clippy::disallowed_methods)]
-                user.remove_field(&field);
-            }
-
-            user.apply_options(partial.clone());
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-
-    /// Set relationship with another user
-    ///
-    /// This should use pull_relationship if relationship is None or User.
-    async fn set_relationship(
-        &self,
-        user_id: &str,
-        target_id: &str,
-        relationship: &RelationshipStatus,
-    ) -> Result<()> {
-        if let RelationshipStatus::User | RelationshipStatus::None = &relationship {
-            self.pull_relationship(user_id, target_id).await
-        } else {
-            let mut users = self.users.lock().await;
-            let user = users
-                .get_mut(user_id)
-                .ok_or_else(|| create_error!(NotFound))?;
-
-            let relation = Relationship {
-                id: target_id.to_string(),
-                status: relationship.clone(),
-            };
-
-            if let Some(relations) = &mut user.relations {
-                relations.retain(|relation| relation.id != target_id);
-                relations.push(relation);
-            } else {
-                user.relations = Some(vec![relation]);
-            }
-
-            Ok(())
-        }
-    }
-
-    /// Remove relationship with another user
-    async fn pull_relationship(&self, user_id: &str, target_id: &str) -> Result<()> {
-        let mut users = self.users.lock().await;
-        let user = users
-            .get_mut(user_id)
-            .ok_or_else(|| create_error!(NotFound))?;
-
-        if let Some(relations) = &mut user.relations {
-            relations.retain(|relation| relation.id != target_id);
-        }
-
-        Ok(())
-    }
-
-    /// Delete a user by their id
-    async fn delete_user(&self, id: &str) -> Result<()> {
-        let mut users = self.users.lock().await;
-        if users.remove(id).is_some() {
-            Ok(())
-        } else {
-            Err(create_error!(NotFound))
-        }
-    }
-}

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

@@ -1,44 +0,0 @@
-use authifier::models::Session;
-use rocket::http::Status;
-use rocket::request::{self, FromRequest, Outcome, Request};
-
-use crate::{Database, User};
-
-#[rocket::async_trait]
-impl<'r> FromRequest<'r> for User {
-    type Error = authifier::Error;
-
-    async fn from_request(request: &'r Request<'_>) -> request::Outcome<Self, Self::Error> {
-        let user: &Option<User> = request
-            .local_cache_async(async {
-                let db = request.rocket().state::<Database>().expect("`Database`");
-
-                let header_bot_token = request
-                    .headers()
-                    .get("x-bot-token")
-                    .next()
-                    .map(|x| x.to_string());
-
-                if let Some(bot_token) = header_bot_token {
-                    if let Ok(bot) = db.fetch_bot_by_token(&bot_token).await {
-                        if let Ok(user) = db.fetch_user(&bot.id).await {
-                            return Some(user);
-                        }
-                    }
-                } else if let Outcome::Success(session) = request.guard::<Session>().await {
-                    if let Ok(user) = db.fetch_user(&session.user_id).await {
-                        return Some(user);
-                    }
-                }
-
-                None
-            })
-            .await;
-
-        if let Some(user) = user {
-            Outcome::Success(user.clone())
-        } else {
-            Outcome::Failure((Status::Unauthorized, authifier::Error::InvalidSession))
-        }
-    }
-}

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

@@ -1,31 +0,0 @@
-use revolt_okapi::openapi3::{SecurityScheme, SecuritySchemeData};
-use revolt_rocket_okapi::{
-    gen::OpenApiGenerator,
-    request::{OpenApiFromRequest, RequestHeaderInput},
-};
-
-use crate::User;
-
-impl<'r> OpenApiFromRequest<'r> for User {
-    fn from_request_input(
-        _gen: &mut OpenApiGenerator,
-        _name: String,
-        _required: bool,
-    ) -> revolt_rocket_okapi::Result<RequestHeaderInput> {
-        let mut requirements = schemars::Map::new();
-        requirements.insert("Session Token".to_owned(), vec![]);
-
-        Ok(RequestHeaderInput::Security(
-            "Session Token".to_owned(),
-            SecurityScheme {
-                data: SecuritySchemeData::ApiKey {
-                    name: "x-session-token".to_owned(),
-                    location: "header".to_owned(),
-                },
-                description: Some("Used to authenticate as a user.".to_owned()),
-                extensions: schemars::Map::new(),
-            },
-            requirements,
-        ))
-    }
-}

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

@@ -1,170 +0,0 @@
-use crate::{models::Message, AppendMessage, Database};
-
-use futures::future::join_all;
-use linkify::{LinkFinder, LinkKind};
-use regex::Regex;
-use revolt_config::config;
-use revolt_result::Result;
-
-use async_lock::Semaphore;
-use async_std::task::spawn;
-use deadqueue::limited::Queue;
-use once_cell::sync::Lazy;
-use revolt_models::v0::Embed;
-use std::{collections::HashSet, sync::Arc};
-
-use isahc::prelude::*;
-
-/// Task information
-#[derive(Debug)]
-struct EmbedTask {
-    /// Channel we're processing the event in
-    channel: String,
-    /// ID of the message we're processing
-    id: String,
-    /// Content of the message
-    content: String,
-}
-
-static Q: Lazy<Queue<EmbedTask>> = Lazy::new(|| Queue::new(10_000));
-
-/// Queue a new task for a worker
-pub async fn queue(channel: String, id: String, content: String) {
-    Q.try_push(EmbedTask {
-        channel,
-        id,
-        content,
-    })
-    .ok();
-
-    info!("Queue is using {} slots from {}.", Q.len(), Q.capacity());
-}
-
-/// Start a new worker
-pub async fn worker(db: Database) {
-    let semaphore = Arc::new(Semaphore::new(
-        config().await.api.workers.max_concurrent_connections,
-    ));
-
-    loop {
-        let task = Q.pop().await;
-        let db = db.clone();
-        let semaphore = semaphore.clone();
-
-        spawn(async move {
-            let config = config().await;
-            let embeds = generate(
-                task.content,
-                &config.hosts.january,
-                config.features.limits.default.message_embeds,
-                semaphore,
-            )
-            .await;
-
-            if let Ok(embeds) = embeds {
-                if let Err(err) = Message::append(
-                    &db,
-                    task.id,
-                    task.channel,
-                    AppendMessage {
-                        embeds: Some(embeds),
-                    },
-                )
-                .await
-                {
-                    error!("Encountered an error appending to message: {:?}", err);
-                }
-            }
-        });
-    }
-}
-
-static RE_CODE: Lazy<Regex> = Lazy::new(|| Regex::new("```(?:.|\n)+?```|`(?:.|\n)+?`").unwrap());
-static RE_IGNORED: Lazy<Regex> = Lazy::new(|| Regex::new("(<http.+>)").unwrap());
-
-pub async fn generate(
-    content: String,
-    host: &str,
-    max_embeds: usize,
-    semaphore: Arc<Semaphore>,
-) -> Result<Vec<Embed>> {
-    // Ignore code blocks.
-    let content = RE_CODE.replace_all(&content, "");
-
-    // Ignore all content between angle brackets starting with http.
-    let content = RE_IGNORED.replace_all(&content, "");
-
-    let content = content
-        // Ignore quoted lines.
-        .split('\n')
-        .map(|v| {
-            if let Some(c) = v.chars().next() {
-                if c == '>' {
-                    return "";
-                }
-            }
-
-            v
-        })
-        .collect::<Vec<&str>>()
-        .join("\n");
-
-    let mut finder = LinkFinder::new();
-    finder.kinds(&[LinkKind::Url]);
-
-    // Process all links, stripping anchors and
-    // only taking up to `max_embeds` of links.
-    let links: Vec<String> = finder
-        .links(&content)
-        .map(|x| {
-            x.as_str()
-                .chars()
-                .take_while(|&ch| ch != '#')
-                .collect::<String>()
-        })
-        .collect::<HashSet<String>>()
-        .into_iter()
-        .take(max_embeds)
-        .collect();
-
-    // If no links, fail out.
-    if links.is_empty() {
-        return Err(create_error!(LabelMe));
-    }
-
-    // TODO: batch request to january
-    let mut tasks = Vec::new();
-
-    for link in links {
-        let semaphore = semaphore.clone();
-        let host = host.to_string();
-        tasks.push(spawn(async move {
-            let guard = semaphore.acquire().await;
-
-            if let Ok(mut response) = isahc::get_async(format!(
-                "{host}/embed?url={}",
-                url_escape::encode_component(&link)
-            ))
-            .await
-            {
-                drop(guard);
-                response.json::<Embed>().await.ok()
-            } else {
-                None
-            }
-        }));
-    }
-
-    let embeds = join_all(tasks)
-        .await
-        .into_iter()
-        .flatten()
-        .collect::<Vec<Embed>>();
-
-    // Prevent database update when no embeds are found.
-    if !embeds.is_empty() {
-        Ok(embeds)
-    } else {
-        Err(create_error!(LabelMe))
-    }
-}