feature: rewrite season subscription extractor

apps/recorder/src/app/builder.rs

@@ -1,5 +1,3 @@
-use std::sync::Arc;
-
 use clap::{Parser, command};
 
 use super::{AppContext, core::App, env::Environment};
@@ -83,9 +81,8 @@ impl AppBuilder {
         )
         .await?;
 
-        let app_context = Arc::new(
-            AppContext::new(self.environment.clone(), config, self.working_dir.clone()).await?,
-        );
+        let app_context =
+            AppContext::new(self.environment.clone(), config, self.working_dir.clone()).await?;
 
         Ok(App {
             context: app_context,

apps/recorder/src/app/config/default_mixin.toml

@@ -16,3 +16,7 @@ depth_limit = inf
 complexity_limit = inf
 
 [cache]
+
+[crypto]
+
+[task]

apps/recorder/src/app/config/mod.rs

@@ -9,9 +9,9 @@ use serde::{Deserialize, Serialize};
 
 use super::env::Environment;
 use crate::{
-    auth::AuthConfig, cache::CacheConfig, database::DatabaseConfig, errors::RecorderResult,
-    extract::mikan::MikanConfig, graphql::GraphQLConfig, logger::LoggerConfig,
-    storage::StorageConfig, web::WebServerConfig,
+    auth::AuthConfig, cache::CacheConfig, crypto::CryptoConfig, database::DatabaseConfig,
+    errors::RecorderResult, extract::mikan::MikanConfig, graphql::GraphQLConfig,
+    logger::LoggerConfig, storage::StorageConfig, tasks::TaskConfig, web::WebServerConfig,
 };
 
 const DEFAULT_CONFIG_MIXIN: &str = include_str!("./default_mixin.toml");
@@ -24,9 +24,11 @@ pub struct AppConfig {
     pub auth: AuthConfig,
     pub storage: StorageConfig,
     pub mikan: MikanConfig,
+    pub crypto: CryptoConfig,
     pub graphql: GraphQLConfig,
     pub logger: LoggerConfig,
     pub database: DatabaseConfig,
+    pub tasks: TaskConfig,
 }
 
 impl AppConfig {

apps/recorder/src/app/context.rs

@@ -1,11 +1,15 @@
+use std::{fmt::Debug, sync::Arc};
+
+use tokio::sync::OnceCell;
+
 use super::{Environment, config::AppConfig};
 use crate::{
-    auth::AuthService, cache::CacheService, database::DatabaseService, errors::RecorderResult,
-    extract::mikan::MikanClient, graphql::GraphQLService, logger::LoggerService,
-    storage::StorageService,
+    auth::AuthService, cache::CacheService, crypto::CryptoService, database::DatabaseService,
+    errors::RecorderResult, extract::mikan::MikanClient, graphql::GraphQLService,
+    logger::LoggerService, storage::StorageService, tasks::TaskService,
 };
 
-pub trait AppContextTrait: Send + Sync {
+pub trait AppContextTrait: Send + Sync + Debug {
     fn logger(&self) -> &LoggerService;
     fn db(&self) -> &DatabaseService;
     fn config(&self) -> &AppConfig;
@@ -16,6 +20,8 @@ pub trait AppContextTrait: Send + Sync {
     fn storage(&self) -> &StorageService;
     fn working_dir(&self) -> &String;
     fn environment(&self) -> &Environment;
+    fn crypto(&self) -> &CryptoService;
+    fn task(&self) -> &TaskService;
 }
 
 pub struct AppContext {
@@ -27,8 +33,10 @@ pub struct AppContext {
     auth: AuthService,
     graphql: GraphQLService,
     storage: StorageService,
+    crypto: CryptoService,
     working_dir: String,
     environment: Environment,
+    task: OnceCell<TaskService>,
 }
 
 impl AppContext {
@@ -36,7 +44,7 @@ impl AppContext {
         environment: Environment,
         config: AppConfig,
         working_dir: impl ToString,
-    ) -> RecorderResult<Self> {
+    ) -> RecorderResult<Arc<Self>> {
         let config_cloned = config.clone();
 
         let logger = LoggerService::from_config(config.logger).await?;
@@ -45,9 +53,10 @@ impl AppContext {
         let storage = StorageService::from_config(config.storage).await?;
         let auth = AuthService::from_conf(config.auth).await?;
         let mikan = MikanClient::from_config(config.mikan).await?;
+        let crypto = CryptoService::from_config(config.crypto).await?;
         let graphql = GraphQLService::from_config_and_database(config.graphql, db.clone()).await?;
 
-        Ok(AppContext {
+        let ctx = Arc::new(AppContext {
             config: config_cloned,
             environment,
             logger,
@@ -58,9 +67,26 @@ impl AppContext {
             mikan,
             working_dir: working_dir.to_string(),
             graphql,
-        })
+            crypto,
+            task: OnceCell::new(),
+        });
+
+        ctx.task
+            .get_or_try_init(async || {
+                TaskService::from_config_and_ctx(config.tasks, ctx.clone()).await
+            })
+            .await?;
+
+        Ok(ctx)
     }
 }
+
+impl Debug for AppContext {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "AppContext")
+    }
+}
+
 impl AppContextTrait for AppContext {
     fn logger(&self) -> &LoggerService {
         &self.logger
@@ -92,4 +118,10 @@ impl AppContextTrait for AppContext {
     fn environment(&self) -> &Environment {
         &self.environment
     }
+    fn crypto(&self) -> &CryptoService {
+        &self.crypto
+    }
+    fn task(&self) -> &TaskService {
+        self.task.get().expect("task should be set")
+    }
 }