deps: update deps

apps/recorder/src/app.rs

@@ -5,6 +5,7 @@ use loco_rs::{
     app::{AppContext, Hooks},
     boot::{create_app, BootResult, StartMode},
     cache,
+    config::Config,
     controller::AppRoutes,
     db::truncate_table,
     environment::Environment,
@@ -25,6 +26,8 @@ use crate::{
     workers::subscription_worker::SubscriptionWorker,
 };
 
+pub const CONFIG_FOLDER: &str = "LOCO_CONFIG_FOLDER";
+
 pub trait AppContextExt {
     fn get_dal_client(&self) -> &AppDalClient {
         AppDalClient::app_instance()
@@ -49,6 +52,20 @@ pub struct App;
 
 #[async_trait]
 impl Hooks for App {
+    async fn load_config(env: &Environment) -> Result<Config> {
+        std::env::var(CONFIG_FOLDER).map_or_else(
+            |_| {
+                let monorepo_project_config_dir = Path::new("./apps/recorder/config");
+                if monorepo_project_config_dir.exists() && monorepo_project_config_dir.is_dir() {
+                    return env.load_from_folder(monorepo_project_config_dir);
+                }
+                let current_config_dir = Path::new("./config");
+                env.load_from_folder(current_config_dir)
+            },
+            |config_folder| env.load_from_folder(Path::new(&config_folder)),
+        )
+    }
+
     fn app_name() -> &'static str {
         env!("CARGO_CRATE_NAME")
     }
@@ -73,8 +90,12 @@ impl Hooks for App {
         )
     }
 
-    async fn boot(mode: StartMode, environment: &Environment) -> Result<BootResult> {
-        create_app::<Self, Migrator>(mode, environment).await
+    async fn boot(
+        mode: StartMode,
+        environment: &Environment,
+        config: Config,
+    ) -> Result<BootResult> {
+        create_app::<Self, Migrator>(mode, environment, config).await
     }
 
     fn routes(ctx: &AppContext) -> AppRoutes {

apps/recorder/src/auth/basic.rs

@@ -1,6 +1,7 @@
 use async_trait::async_trait;
-use axum::{http::request::Parts, RequestPartsExt};
-use axum_auth::AuthBasic;
+use axum::http::request::Parts;
+use base64::{self, Engine};
+use reqwest::header::AUTHORIZATION;
 
 use super::{
     config::BasicAuthConfig,
@@ -9,6 +10,48 @@ use super::{
 };
 use crate::models::{auth::AuthType, subscribers::SEED_SUBSCRIBER};
 
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub struct AuthBasic {
+    pub user: String,
+    pub password: Option<String>,
+}
+
+impl AuthBasic {
+    fn decode_request_parts(req: &mut Parts) -> Result<Self, AuthError> {
+        let authorization = req
+            .headers
+            .get(AUTHORIZATION)
+            .and_then(|s| s.to_str().ok())
+            .ok_or_else(|| AuthError::BasicInvalidCredentials)?;
+
+        let split = authorization.split_once(' ');
+
+        match split {
+            Some((name, contents)) if name == "Basic" => {
+                let decoded = base64::engine::general_purpose::STANDARD
+                    .decode(contents)
+                    .map_err(|_| AuthError::BasicInvalidCredentials)?;
+
+                let decoded =
+                    String::from_utf8(decoded).map_err(|_| AuthError::BasicInvalidCredentials)?;
+
+                Ok(if let Some((user, password)) = decoded.split_once(':') {
+                    Self {
+                        user: String::from(user),
+                        password: Some(String::from(password)),
+                    }
+                } else {
+                    Self {
+                        user: decoded,
+                        password: None,
+                    }
+                })
+            }
+            _ => Err(AuthError::BasicInvalidCredentials),
+        }
+    }
+}
+
 #[derive(Debug)]
 pub struct BasicAuthService {
     pub config: BasicAuthConfig,
@@ -17,7 +60,11 @@ pub struct BasicAuthService {
 #[async_trait]
 impl AuthService for BasicAuthService {
     async fn extract_user_info(&self, request: &mut Parts) -> Result<AuthUserInfo, AuthError> {
-        if let Ok(AuthBasic((found_user, found_password))) = request.extract().await {
+        if let Ok(AuthBasic {
+            user: found_user,
+            password: found_password,
+        }) = AuthBasic::decode_request_parts(request)
+        {
             if self.config.user == found_user
                 && self.config.password == found_password.unwrap_or_default()
             {

apps/recorder/src/auth/service.rs

@@ -22,7 +22,6 @@ pub struct AuthUserInfo {
     pub auth_type: AuthType,
 }
 
-#[async_trait]
 impl<S> FromRequestParts<S> for AuthUserInfo
 where
     S: Send + Sync,

apps/recorder/src/controllers/graphql.rs

@@ -1,7 +1,10 @@
 use async_graphql::http::{playground_source, GraphQLPlaygroundConfig};
 use async_graphql_axum::GraphQL;
-use axum::response::Html;
-use loco_rs::prelude::*;
+use axum::{
+    response::{Html, IntoResponse},
+    routing::{get, post_service},
+};
+use loco_rs::prelude::Routes;
 
 use crate::graphql::service::AppGraphQLService;
 
@@ -12,8 +15,11 @@ pub async fn graphql_playground() -> impl IntoResponse {
 }
 
 pub fn routes(graphql_service: &AppGraphQLService) -> Routes {
-    Routes::new().prefix("/graphql").add(
-        "/",
-        get(graphql_playground).post_service(GraphQL::new(graphql_service.schema.clone())),
-    )
+    Routes::new()
+        .prefix("/graphql")
+        .add("/playground", get(graphql_playground))
+        .add(
+            "/",
+            post_service(GraphQL::new(graphql_service.schema.clone())),
+        )
 }

apps/recorder/src/graphql/query_root.rs

@@ -15,7 +15,6 @@ pub fn schema(
     seaography::register_entities!(
         builder,
         [
-            auth,
             bangumi,
             downloaders,
             downloads,
@@ -28,7 +27,6 @@ pub fn schema(
     );
 
     {
-        builder.register_enumeration::<auth::AuthType>();
         builder.register_enumeration::<downloads::DownloadStatus>();
         builder.register_enumeration::<subscriptions::SubscriptionCategory>();
         builder.register_enumeration::<downloaders::DownloaderCategory>();

apps/recorder/src/migrations/m20220101_000001_init.rs

@@ -1,5 +1,4 @@
 use async_trait::async_trait;
-use loco_rs::schema::jsonb_null;
 use sea_orm_migration::{prelude::*, schema::*};
 
 use super::defs::{
@@ -27,7 +26,7 @@ impl MigrationTrait for Migration {
                     .col(pk_auto(Subscribers::Id))
                     .col(string_len_uniq(Subscribers::Pid, 64))
                     .col(string(Subscribers::DisplayName))
-                    .col(jsonb_null(Subscribers::BangumiConf))
+                    .col(json_binary_null(Subscribers::BangumiConf))
                     .to_owned(),
             )
             .await?;
@@ -101,13 +100,13 @@ impl MigrationTrait for Migration {
                     .col(text_null(Bangumi::SeasonRaw))
                     .col(text_null(Bangumi::Fansub))
                     .col(text_null(Bangumi::MikanFansubId))
-                    .col(jsonb_null(Bangumi::Filter))
+                    .col(json_binary_null(Bangumi::Filter))
                     .col(text_null(Bangumi::RssLink))
                     .col(text_null(Bangumi::PosterLink))
                     .col(text_null(Bangumi::SavePath))
                     .col(boolean(Bangumi::Deleted).default(false))
                     .col(text_null(Bangumi::Homepage))
-                    .col(jsonb_null(Bangumi::Extra))
+                    .col(json_binary_null(Bangumi::Extra))
                     .foreign_key(
                         ForeignKey::create()
                             .name("fk_bangumi_subscriber_id")
@@ -214,7 +213,7 @@ impl MigrationTrait for Migration {
                     .col(text_null(Episodes::Subtitle))
                     .col(boolean(Episodes::Deleted).default(false))
                     .col(text_null(Episodes::Source))
-                    .col(jsonb_null(Episodes::Extra))
+                    .col(json_binary_null(Episodes::Extra))
                     .foreign_key(
                         ForeignKey::create()
                             .name("fk_episodes_bangumi_id")

apps/recorder/src/models/auth.rs

@@ -45,11 +45,5 @@ impl Related<super::subscribers::Entity> for Entity {
     }
 }
 
-#[derive(Copy, Clone, Debug, EnumIter, DeriveRelatedEntity)]
-pub enum RelatedEntity {
-    #[sea_orm(entity = "super::subscribers::Entity")]
-    Subscriber,
-}
-
 #[async_trait]
 impl ActiveModelBehavior for ActiveModel {}

apps/recorder/src/models/episodes.rs

@@ -45,7 +45,7 @@ pub struct Model {
     pub poster_link: Option<String>,
     pub episode_index: i32,
     pub homepage: Option<String>,
-    pub subtitle: Option<Vec<String>>,
+    pub subtitle: Option<String>,
     #[sea_orm(default = "false")]
     pub deleted: bool,
     pub source: Option<String>,
@@ -218,7 +218,7 @@ impl ActiveModel {
             poster_link: ActiveValue::Set(bgm.poster_link.clone()),
             episode_index: ActiveValue::Set(raw_meta.episode_index),
             homepage: ActiveValue::Set(Some(homepage.to_string())),
-            subtitle: ActiveValue::Set(raw_meta.subtitle.map(|s| vec![s])),
+            subtitle: ActiveValue::Set(raw_meta.subtitle),
             source: ActiveValue::Set(raw_meta.source),
             extra: ActiveValue::Set(EpisodeExtra {
                 name_zh: raw_meta.name_zh,

apps/recorder/src/models/subscribers.rs

@@ -80,8 +80,6 @@ pub enum RelatedEntity {
     Bangumi,
     #[sea_orm(entity = "super::episodes::Entity")]
     Episode,
-    #[sea_orm(entity = "super::auth::Entity")]
-    Auth,
 }
 
 #[derive(Debug, Deserialize, Serialize)]