merge: branch 'master' into insert/feat/user-safety-api

crates/delta/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "revolt-delta"
-version = "0.5.5"
+version = "0.5.7"
 license = "AGPL-3.0-or-later"
 authors = ["Paul Makles <paulmakles@gmail.com>"]
 edition = "2018"
@@ -51,13 +51,12 @@ mobc-redis = { version = "0.7.0", default-features = false, features = ["async-s
 
 # web
 rocket = { version = "0.5.0-rc.2", default-features = false, features = ["json"] }
-rocket_empty = { git = "https://github.com/insertish/rocket_empty", branch = "master" }
-rocket_rauth = { git = "https://github.com/insertish/rauth", rev = "cbdec69c684a4854fbedba9ed1f0e7ee466bf3f7" }
+rocket_empty = { version = "0.1.1", features = ["schema"] }
+rocket_authifier = { version = "1.0.7" }
 
 # spec generation
 schemars = "0.8.8"
-# rocket_okapi = "0.8.0-rc.1"
-rocket_okapi = { git = "https://github.com/insertish/okapi", rev = "a1048d0c8cd771e424ec97d33d825c32e06aa120", features = [ "swagger" ] }
+revolt_rocket_okapi = { version = "0.9.1", features = [ "swagger" ] }
 
 # quark
 revolt-quark = { path = "../quark" }

crates/delta/build.rs

@@ -12,5 +12,5 @@ fn main() {
         }
     }
 
-    vergen(Config::default()).unwrap();
+    vergen(Config::default()).ok();
 }

crates/delta/src/main.rs

@@ -1,7 +1,7 @@
 #[macro_use]
 extern crate rocket;
 #[macro_use]
-extern crate rocket_okapi;
+extern crate revolt_rocket_okapi;
 #[macro_use]
 extern crate serde_json;
 #[macro_use]
@@ -10,7 +10,9 @@ extern crate lazy_static;
 pub mod routes;
 pub mod util;
 
-use revolt_quark::rauth::RAuth;
+use async_std::channel::unbounded;
+use revolt_quark::authifier::{Authifier, AuthifierEvent};
+use revolt_quark::events::client::EventV1;
 use revolt_quark::DatabaseInfo;
 
 #[launch]
@@ -25,13 +27,33 @@ async fn rocket() -> _ {
     let db = DatabaseInfo::Auto.connect().await.unwrap();
     db.migrate_database().await.unwrap();
 
-    // Setup rAuth
-    let rauth = RAuth {
+    // Setup Authifier event channel
+    let (sender, receiver) = unbounded();
+
+    // Setup Authifier
+    let authifier = Authifier {
         database: db.clone().into(),
-        config: revolt_quark::util::rauth::config(),
+        config: revolt_quark::util::authifier::config(),
+        event_channel: Some(sender),
     };
 
-    // Launch background task workers.
+    // Launch a listener for Authifier events
+    async_std::task::spawn(async move {
+        while let Ok(event) = receiver.recv().await {
+            match &event {
+                AuthifierEvent::CreateSession { .. } | AuthifierEvent::CreateAccount { .. } => {
+                    EventV1::Auth(event).global().await
+                }
+                AuthifierEvent::DeleteSession { user_id, .. }
+                | AuthifierEvent::DeleteAllSessions { user_id, .. } => {
+                    let id = user_id.to_string();
+                    EventV1::Auth(event).private(id).await
+                }
+            }
+        }
+    });
+
+    // Launch background task workers
     async_std::task::spawn(revolt_quark::tasks::start_workers(db.clone()));
 
     // Configure CORS
@@ -43,7 +65,7 @@ async fn rocket() -> _ {
         .mount("/", revolt_quark::web::cors::catch_all_options_routes())
         .mount("/", revolt_quark::web::ratelimiter::routes())
         .mount("/swagger/", revolt_quark::web::swagger::routes())
-        .manage(rauth)
+        .manage(authifier)
         .manage(db)
         .manage(cors.clone())
         .attach(revolt_quark::web::ratelimiter::RatelimitFairing)

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

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

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

@@ -65,16 +65,20 @@ pub async fn message_send(
     data.validate()
         .map_err(|error| Error::FailedValidation { error })?;
 
+    // Validate Message is within reasonable length limits
     Message::validate_sum(&data.content, &data.embeds)?;
 
+    // Ensure the request is unique
     idempotency.consume_nonce(data.nonce).await?;
 
+    // Ensure we have permissions to send a message
     let channel = target.as_channel(db).await?;
     let mut permissions = perms(&user).channel(&channel);
     permissions
         .throw_permission_and_view_channel(db, Permission::SendMessage)
         .await?;
 
+    // Check the message is not empty
     if (data.content.as_ref().map_or(true, |v| v.is_empty()))
         && (data.attachments.as_ref().map_or(true, |v| v.is_empty()))
         && (data.embeds.as_ref().map_or(true, |v| v.is_empty()))
@@ -82,6 +86,22 @@ pub async fn message_send(
         return Err(Error::EmptyMessage);
     }
 
+    // Ensure restrict_reactions is not specified without reactions list
+    if let Some(interactions) = &data.interactions {
+        if interactions.restrict_reactions {
+            let disallowed = if let Some(list) = &interactions.reactions {
+                list.is_empty()
+            } else {
+                true
+            };
+
+            if disallowed {
+                return Err(Error::InvalidProperty);
+            }
+        }
+    }
+
+    // Start constructing the message
     let message_id = Ulid::new().to_string();
     let mut message = Message {
         id: message_id.clone(),

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

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

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

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

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

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

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

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

crates/delta/src/routes/mod.rs

@@ -1,7 +1,7 @@
+use revolt_rocket_okapi::{revolt_okapi::openapi3::OpenApi, settings::OpenApiSettings};
 pub use rocket::http::Status;
 pub use rocket::response::Redirect;
 use rocket::{Build, Rocket};
-use rocket_okapi::{okapi::openapi3::OpenApi, settings::OpenApiSettings};
 
 mod bots;
 mod channels;
@@ -29,9 +29,9 @@ pub fn mount(mut rocket: Rocket<Build>) -> Rocket<Build> {
         "/invites" => invites::routes(),
         "/custom" => customisation::routes(),
         "/safety" => safety::routes(),
-        "/auth/account" => rocket_rauth::routes::account::routes(),
-        "/auth/session" => rocket_rauth::routes::session::routes(),
-        "/auth/mfa" => rocket_rauth::routes::mfa::routes(),
+        "/auth/account" => rocket_authifier::routes::account::routes(),
+        "/auth/session" => rocket_authifier::routes::session::routes(),
+        "/auth/mfa" => rocket_authifier::routes::mfa::routes(),
         "/onboard" => onboard::routes(),
         "/push" => push::routes(),
         "/sync" => sync::routes(),
@@ -41,7 +41,7 @@ pub fn mount(mut rocket: Rocket<Build>) -> Rocket<Build> {
 }
 
 fn custom_openapi_spec() -> OpenApi {
-    use rocket_okapi::okapi::openapi3::*;
+    use revolt_rocket_okapi::revolt_okapi::openapi3::*;
 
     let mut extensions = schemars::Map::new();
     extensions.insert(

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

@@ -1,5 +1,7 @@
 use crate::util::regex::RE_USERNAME;
-use revolt_quark::{models::User, rauth::models::Session, Database, EmptyResponse, Error, Result};
+use revolt_quark::{
+    authifier::models::Session, models::User, Database, EmptyResponse, Error, Result,
+};
 
 use rocket::{serde::json::Json, State};
 use serde::{Deserialize, Serialize};

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

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

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

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

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

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

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

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

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

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

crates/delta/src/routes/root.rs

@@ -119,11 +119,21 @@ pub async fn root() -> Result<Json<RevoltConfig>> {
         app: APP_URL.to_string(),
         vapid: VAPID_PUBLIC_KEY.to_string(),
         build: BuildInformation {
-            commit_sha: env!("VERGEN_GIT_SHA").to_string(),
-            commit_timestamp: env!("VERGEN_GIT_COMMIT_TIMESTAMP").to_string(),
-            semver: env!("VERGEN_GIT_SEMVER").to_string(),
-            origin_url: env!("GIT_ORIGIN_URL", "<missing>").to_string(),
-            timestamp: env!("VERGEN_BUILD_TIMESTAMP").to_string(),
+            commit_sha: option_env!("VERGEN_GIT_SHA")
+                .unwrap_or_else(|| "<failed to generate>")
+                .to_string(),
+            commit_timestamp: option_env!("VERGEN_GIT_COMMIT_TIMESTAMP")
+                .unwrap_or_else(|| "<failed to generate>")
+                .to_string(),
+            semver: option_env!("VERGEN_GIT_SEMVER")
+                .unwrap_or_else(|| "<failed to generate>")
+                .to_string(),
+            origin_url: option_env!("GIT_ORIGIN_URL")
+                .unwrap_or_else(|| "<failed to generate>")
+                .to_string(),
+            timestamp: option_env!("VERGEN_BUILD_TIMESTAMP")
+                .unwrap_or_else(|| "<failed to generate>")
+                .to_string(),
         },
     }))
 }

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

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

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

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

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

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

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

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

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

@@ -1,7 +1,7 @@
+use revolt_rocket_okapi::revolt_okapi::openapi3::{self, MediaType, RefOr};
 use rocket::http::ContentType;
 use rocket::response::{self, Responder};
 use rocket::{Request, Response};
-use rocket_okapi::okapi::openapi3::{self, MediaType, RefOr};
 use schemars::schema::{InstanceType, SchemaObject, SingleOrVec};
 
 pub struct CachedFile((ContentType, Vec<u8>));
@@ -16,10 +16,10 @@ impl<'r> Responder<'r, 'static> for CachedFile {
     }
 }
 
-impl rocket_okapi::response::OpenApiResponderInner for CachedFile {
+impl revolt_rocket_okapi::response::OpenApiResponderInner for CachedFile {
     fn responses(
-        _gen: &mut rocket_okapi::gen::OpenApiGenerator,
-    ) -> std::result::Result<openapi3::Responses, rocket_okapi::OpenApiError> {
+        _gen: &mut revolt_rocket_okapi::gen::OpenApiGenerator,
+    ) -> std::result::Result<openapi3::Responses, revolt_rocket_okapi::OpenApiError> {
         let mut responses = schemars::Map::new();
         let mut content = schemars::Map::new();
 

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

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