Merge pull request #13 from habibi-dev/develop

💰 refactor(core): Jobs & state cleanup + add Iranian coins API

Author: habibi-dev

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "rust_rest_api"
-version = "0.2.1"
+version = "0.3.0"
 edition = "2024"
 license = "MIT"
 authors = ["Habibi-Dev"]
@@ -22,8 +22,10 @@ sea-orm = { version = "1.1.16", features = ["sqlx-sqlite", "runtime-tokio-rustls
 once_cell = "1.21.3"
 rust-embed = "8.7.2"
 askama = { version = "0.14", features = ["full"] }
-http = "1.3.1"
 mime_guess = "2.0.5"
+reqwest = { version = "0.12.23", features = ["__rustls", "json", "rustls-tls"] }
+uuid = { version = "1.18.1", features = ["v4"] }
+anyhow = "1.0.100"
 
 [dependencies.migration]
 path = "./migration"

Cargo.toml

@@ -0,0 +1,63 @@
+use crate::core::config::Config;
+use crate::jobs::{cache_flush::CacheFlushJob, coin_sync::CoinSyncJob};
+use crate::server;
+use crate::services::{cache::StatsCache, routes::Routes};
+use crate::state::{self, APP_STATE, AppState};
+use anyhow::{Context, Result};
+use migration::{Migrator, MigratorTrait};
+use sea_orm::Database;
+use std::sync::Arc;
+
+pub async fn run() -> Result<()> {
+    let config = load_config()?;
+    let db = setup_database().await?;
+    let cache = Arc::new(StatsCache::new(db.clone()));
+
+    state::State::init(db, Arc::clone(&cache));
+
+    start_background_jobs(&cache)?;
+
+    let app_state = get_app_state()?;
+    let app = Routes::routes(app_state);
+
+    server::http::start_http(app, &config)
+        .await
+        .map_err(|e| anyhow::anyhow!("Failed to start HTTP server: {}", e))?;
+
+    Ok(())
+}
+
+fn load_config() -> Result<Config> {
+    Ok(Config::from_env())
+}
+
+async fn setup_database() -> Result<sea_orm::DatabaseConnection> {
+    let db_url =
+        std::env::var("DATABASE_URL").context("DATABASE_URL environment variable is required")?;
+
+    let db = Database::connect(&db_url)
+        .await
+        .context("Failed to connect to database")?;
+
+    Migrator::up(&db, None)
+        .await
+        .context("Database migration failed")?;
+
+    Ok(db)
+}
+
+fn start_background_jobs(cache: &Arc<StatsCache>) -> Result<()> {
+    let flush_job = CacheFlushJob::new(Arc::clone(cache));
+    let coin_job = CoinSyncJob::new();
+
+    crate::services::jobs::FlushJob::start(vec![flush_job.into_task(), coin_job.into_task()], None);
+
+    Ok(())
+}
+
+fn get_app_state() -> Result<AppState> {
+    APP_STATE
+        .get()
+        .cloned()
+        .context("Application state not initialized")
+}

src/app.rs

@@ -0,0 +1,26 @@
+use crate::jobs::JobTask;
+use crate::services::cache::StatsCache;
+use std::sync::Arc;
+
+pub struct CacheFlushJob {
+    cache: Arc<StatsCache>,
+}
+
+impl CacheFlushJob {
+    pub fn new(cache: Arc<StatsCache>) -> Self {
+        Self { cache }
+    }
+
+    pub fn into_task(self) -> JobTask {
+        let cache = self.cache;
+
+        Arc::new(move || {
+            let cache_clone = Arc::clone(&cache);
+            Box::pin(async move {
+                if let Err(e) = cache_clone.flush_to_db().await {
+                    eprintln!("Cache flush job failed: {}", e);
+                }
+            })
+        })
+    }
+}

src/assets/index-Bu-dXgft.css

@@ -0,0 +1,36 @@
+use crate::jobs::JobTask;
+use crate::services::coin_ir::request::RequestCoinIr;
+use crate::state::APP_STATE;
+use std::sync::Arc;
+
+pub struct CoinSyncJob;
+
+impl CoinSyncJob {
+    pub fn new() -> Self {
+        Self
+    }
+
+    pub fn into_task(self) -> JobTask {
+        Arc::new(|| {
+            Box::pin(async {
+                if let Err(e) = sync_coins().await {
+                    eprintln!("Coin sync job failed: {}", e);
+                }
+            })
+        })
+    }
+}
+
+async fn sync_coins() -> Result<(), Box<dyn std::error::Error>> {
+    let service = RequestCoinIr::new();
+    let coins = service.coins_typed().await?;
+
+    let state = APP_STATE.get().ok_or("Application state not available")?;
+
+    state
+        .coin_tx
+        .send(coins)
+        .map_err(|_| "Failed to send coins to channel")?;
+
+    Ok(())
+}

src/assets/index-C2f6evCj.css

@@ -0,0 +1,6 @@
+pub mod cache_flush;
+pub mod coin_sync;
+
+use std::{future::Future, pin::Pin, sync::Arc};
+
+pub type JobTask = Arc<dyn Fn() -> Pin<Box<dyn Future<Output = ()> + Send>> + Send + Sync>;

src/assets/index-DM3BAv3J.js src/assets/index-DqpVWQNW.jssrc/assets/index-DM3BAv3J.js renamed to src/assets/index-DqpVWQNW.js

@@ -1,42 +1,18 @@
+mod app;
 mod core;
 mod entities;
+mod jobs;
 mod middleware;
 mod repository;
 mod server;
 mod services;
+mod state;
 mod utility;
 
-use crate::services::{cache::StatsCache, jobs::FlushJob, routes::Routes};
-use core::config::Config;
-use migration::{Migrator, MigratorTrait};
-use sea_orm::Database;
-use std::{sync::OnceLock, time::Instant};
-
-static START: OnceLock<Instant> = OnceLock::new();
-
 #[tokio::main]
 async fn main() {
-    START.set(Instant::now()).ok();
-
-    let config = Config::from_env();
-    let db_url = std::env::var("DATABASE_URL").expect("DATABASE_URL is required");
-
-    let db = Database::connect(&db_url).await.expect("DB connect failed");
-    Migrator::up(&db, None).await.expect("Migration failed");
-
-    let cache = StatsCache::new(db.clone());
-
-    // Start background flush job
-    FlushJob::start(cache.clone());
-
-    let state = services::AppState {
-        _db: db,
-        stats_cache: cache,
-    };
-    let app = Routes::routes(state);
-
-    if let Err(e) = server::http::start_http(app, &config).await {
-        eprintln!("Fatal server error: {}", e);
+    if let Err(e) = app::run().await {
+        eprintln!("Application failed to start: {}", e);
         std::process::exit(1);
     }
 }