Merge remote-tracking branch 'revoltchat/master' into webhooks

crates/delta/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-delta"
-version = "0.5.17"
+version = "0.5.19"
 license = "AGPL-3.0-or-later"
 authors = ["Paul Makles <paulmakles@gmail.com>"]
 edition = "2018"
@@ -43,11 +43,6 @@ async-std = { version = "1.8.0", features = ["tokio1", "tokio02", "attributes"]
 # internal util
 lettre = "0.10.0-alpha.4"
 
-# redis
-redis = { version = "0.21.2", features = ["async-std-comp"] }
-mobc = { version = "0.7.3" }
-mobc-redis = { version = "0.7.0", default-features = false, features = ["async-std-comp"] }
-
 # web
 rocket = { version = "0.5.0-rc.2", default-features = false, features = ["json"] }
 rocket_empty = { version = "0.1.1", features = ["schema"] }
@@ -60,5 +55,9 @@ revolt_rocket_okapi = { version = "0.9.1", features = [ "swagger" ] }
 # quark
 revolt-quark = { path = "../quark" }
 
+# core
+revolt-database = { path = "../core/database", features = [ "rocket-impl" ] }
+revolt-models = { path = "../core/models", features = [ "schemas", "redis-is-patched" ] }
+
 [build-dependencies]
 vergen = "7.5.0"

crates/delta/Dockerfile

@@ -1,11 +1,12 @@
 # Build Stage
 FROM ghcr.io/revoltchat/base:latest AS builder
-RUN cargo install --locked --path crates/delta
 
 # Bundle Stage
-FROM debian:buster-slim
-RUN apt-get update && apt-get install -y ca-certificates
-COPY --from=builder /usr/local/cargo/bin/revolt-delta ./
+FROM debian:bullseye-slim
+RUN apt-get update && \
+    apt-get install -y ca-certificates && \
+    apt-get clean
+COPY --from=builder /home/rust/src/target/release/revolt-delta ./
 
 EXPOSE 8000
 ENV ROCKET_ADDRESS 0.0.0.0

crates/delta/src/main.rs

@@ -23,15 +23,18 @@ async fn rocket() -> _ {
     revolt_quark::variables::delta::preflight_checks();
 
     // Setup database
-    let db = DatabaseInfo::Auto.connect().await.unwrap();
+    let db = revolt_database::DatabaseInfo::Auto.connect().await.unwrap();
     db.migrate_database().await.unwrap();
 
+    // Legacy database setup from quark
+    let legacy_db = DatabaseInfo::Auto.connect().await.unwrap();
+
     // Setup Authifier event channel
     let (sender, receiver) = unbounded();
 
     // Setup Authifier
     let authifier = Authifier {
-        database: db.clone().into(),
+        database: legacy_db.clone().into(),
         config: revolt_quark::util::authifier::config(),
         event_channel: Some(sender),
     };
@@ -53,7 +56,7 @@ async fn rocket() -> _ {
     });
 
     // Launch background task workers
-    async_std::task::spawn(revolt_quark::tasks::start_workers(db.clone()));
+    async_std::task::spawn(revolt_quark::tasks::start_workers(legacy_db.clone()));
 
     // Configure CORS
     let cors = revolt_quark::web::cors::new();
@@ -66,6 +69,7 @@ async fn rocket() -> _ {
         .mount("/swagger/", revolt_quark::web::swagger::routes())
         .manage(authifier)
         .manage(db)
+        .manage(legacy_db)
         .manage(cors.clone())
         .attach(revolt_quark::web::ratelimiter::RatelimitFairing)
         .attach(cors)

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

@@ -1,36 +1,33 @@
-use revolt_quark::{
-    models::{Bot, User},
-    Db, Error, Ref, Result,
-};
-use rocket::serde::json::Json;
-use serde::Serialize;
-
-/// # Bot Response
-#[derive(Serialize, JsonSchema)]
-pub struct BotResponse {
-    /// Bot object
-    bot: Bot,
-    /// User object
-    user: User,
-}
+use revolt_database::{util::reference::Reference, Database};
+use revolt_models::v0::FetchBotResponse;
+use revolt_quark::{models::User, Error, Result};
+use rocket::{serde::json::Json, State};
 
 /// # Fetch Bot
 ///
 /// Fetch details of a bot you own by its id.
 #[openapi(tag = "Bots")]
-#[get("/<target>")]
-pub async fn fetch_bot(db: &Db, user: User, target: Ref) -> Result<Json<BotResponse>> {
+#[get("/<bot>")]
+pub async fn fetch_bot(
+    db: &State<Database>,
+    user: User,
+    bot: Reference,
+) -> Result<Json<FetchBotResponse>> {
     if user.bot.is_some() {
         return Err(Error::IsBot);
     }
 
-    let bot = target.as_bot(db).await?;
+    let bot = bot.as_bot(db).await.map_err(Error::from_core)?;
     if bot.owner != user.id {
         return Err(Error::NotFound);
     }
 
-    Ok(Json(BotResponse {
-        user: db.fetch_user(&bot.id).await?.foreign(),
-        bot,
+    Ok(Json(FetchBotResponse {
+        user: revolt_models::v0::User::from(
+            db.fetch_user(&bot.id).await.map_err(Error::from_core)?,
+            None,
+        )
+        .await,
+        bot: bot.into(),
     }))
 }

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

@@ -1,44 +1,25 @@
-use revolt_quark::{
-    models::{File, User},
-    Db, Error, Ref, Result,
-};
+use revolt_database::Database;
+use revolt_models::v0::PublicBot;
+use revolt_quark::{models::User, Error, Ref, Result};
 
 use rocket::serde::json::Json;
-use serde::{Deserialize, Serialize};
-
-/// # Public Bot
-#[derive(Serialize, Deserialize, JsonSchema)]
-pub struct PublicBot {
-    /// Bot Id
-    #[serde(rename = "_id")]
-    id: String,
-    /// Bot Username
-    username: String,
-    /// Profile Avatar
-    #[serde(skip_serializing_if = "Option::is_none")]
-    avatar: Option<File>,
-    /// Profile Description
-    #[serde(skip_serializing_if = "Option::is_none")]
-    description: Option<String>,
-}
+use rocket::State;
 
 /// # Fetch Public Bot
 ///
 /// Fetch details of a public (or owned) bot by its id.
 #[openapi(tag = "Bots")]
 #[get("/<target>/invite")]
-pub async fn fetch_public_bot(db: &Db, user: Option<User>, target: Ref) -> Result<Json<PublicBot>> {
-    let bot = target.as_bot(db).await?;
+pub async fn fetch_public_bot(
+    db: &State<Database>,
+    user: Option<User>,
+    target: Ref,
+) -> Result<Json<PublicBot>> {
+    let bot = db.fetch_bot(&target.id).await.map_err(Error::from_core)?;
     if !bot.public && user.map_or(true, |x| x.id != bot.owner) {
         return Err(Error::NotFound);
     }
 
-    let user = db.fetch_user(&bot.id).await?;
-
-    Ok(Json(PublicBot {
-        id: bot.id,
-        username: user.username,
-        avatar: user.avatar,
-        description: user.profile.and_then(|p| p.content),
-    }))
+    let user = db.fetch_user(&bot.id).await.map_err(Error::from_core)?;
+    Ok(Json(PublicBot::from(bot, user)))
 }

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

@@ -1,6 +1,6 @@
 use revolt_quark::{
     models::{Invite, User},
-    perms, Db, Error, Permission, Ref, Result,
+    perms, Db, Permission, Ref, Result,
 };
 
 use rocket::serde::json::Json;
@@ -11,10 +11,6 @@ use rocket::serde::json::Json;
 #[openapi(tag = "Server Members")]
 #[get("/<target>/invites")]
 pub async fn req(db: &Db, user: User, target: Ref) -> Result<Json<Vec<Invite>>> {
-    if user.bot.is_some() {
-        return Err(Error::IsBot);
-    }
-
     let server = target.as_server(db).await?;
     perms(&user)
         .server(&server)

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

@@ -44,6 +44,10 @@ pub async fn req(
     user: User,
     info: Json<DataCreateServer>,
 ) -> Result<Json<CreateServerResponse>> {
+    if user.bot.is_some() {
+        return Err(Error::IsBot);
+    }
+
     let info = info.into_inner();
     info.validate()
         .map_err(|error| Error::FailedValidation { error })?;