separation of database (#1)

Reviewed-on: #1

libertas_api/src/config.rs

@@ -7,12 +7,13 @@ pub fn load_config() -> CoreResult<Config> {
     Ok(Config {
         database: DatabaseConfig {
             db_type: DatabaseType::Postgres,
-            url: "postgres://postgres:postgres@localhost:5432/libertas_db".to_string(),
+            url: "postgres://libertas:libertas_password@localhost:5436/libertas_db".to_string(),
         },
         server_address: "127.0.0.1:8080".to_string(),
         jwt_secret: "super_secret_jwt_key".to_string(),
         media_library_path: "media_library".to_string(),
         broker_url: "nats://localhost:4222".to_string(),
         max_upload_size_mb: Some(100),
+        default_storage_quota_gb: Some(10),
     })
 }

libertas_api/src/factory.rs

@@ -38,6 +38,7 @@ pub async fn build_app_state(config: Config) -> CoreResult<AppState> {
         user_repo.clone(),
         hasher,
         tokenizer.clone(),
+        Arc::new(config.clone()),
     ));
     let media_service = Arc::new(MediaServiceImpl::new(
         media_repo.clone(),

libertas_api/src/handlers/media_handlers.rs

@@ -37,14 +37,12 @@ impl From<Media> for MediaResponse {
     }
 }
 
-pub fn media_routes() -> Router<AppState> {
-    let max_size_mb = 100; // todo: get from config
-
+pub fn media_routes(max_upload_size: usize) -> Router<AppState> {
     Router::new()
         .route("/", post(upload_media))
         .route("/{id}", get(get_media_details).delete(delete_media))
         .route("/{id}/file", get(get_media_file))
-        .layer(DefaultBodyLimit::max(max_size_mb * 1024 * 1024))
+        .layer(DefaultBodyLimit::max(max_upload_size))
 }
 
 async fn upload_media(

libertas_api/src/main.rs

@@ -28,8 +28,10 @@ async fn main() -> anyhow::Result<()> {
     let addr: SocketAddr = config.server_address.parse()?;
 
     let app_state = factory::build_app_state(config).await?;
+    let max_upload_size =
+        (app_state.config.max_upload_size_mb.unwrap_or(100) * 1024 * 1024) as usize;
 
-    let app = routes::api_routes().with_state(app_state);
+    let app = routes::api_routes(max_upload_size).with_state(app_state);
 
     println!("Starting server at http://{}", addr);
 

libertas_api/src/routes.rs

@@ -5,10 +5,10 @@ use crate::{
     state::AppState,
 };
 
-pub fn api_routes() -> Router<AppState> {
+pub fn api_routes(max_upload_size: usize) -> Router<AppState> {
     let auth_routes = auth_handlers::auth_routes();
     let user_routes = user_handlers::user_routes();
-    let media_routes = media_handlers::media_routes();
+    let media_routes = media_handlers::media_routes(max_upload_size);
     let album_routes = album_handlers::album_routes();
 
     Router::new()

libertas_api/src/services/media_service.rs

@@ -46,89 +46,24 @@ impl MediaServiceImpl {
 #[async_trait]
 impl MediaService for MediaServiceImpl {
     async fn upload_media(&self, mut data: UploadMediaData<'_>) -> CoreResult<Media> {
-        let user = self
-            .user_repo
-            .find_by_id(data.owner_id)
-            .await?
-            .ok_or(CoreError::NotFound("User".to_string(), data.owner_id))?;
+        let (file_bytes, hash, file_size) = self.hash_and_buffer_stream(&mut data).await?;
 
-        let mut hasher = Sha256::new();
-        let mut file_bytes = Vec::new();
+        let owner_id = data.owner_id;
+        let filename = data.filename;
+        let mime_type = data.mime_type;
 
-        while let Some(chunk_result) = data.stream.next().await {
-            let chunk = chunk_result.map_err(|e| CoreError::Io(e))?;
-            hasher.update(&chunk);
-            file_bytes.extend_from_slice(&chunk);
-        }
-        let file_size = file_bytes.len() as i64;
-
-        if user.storage_used + file_size > user.storage_quota {
-            return Err(CoreError::Auth(format!(
-                "Storage quota exceeded. Used: {}, Quota: {}",
-                user.storage_used, user.storage_quota
-            )));
-        }
-
-        let hash = format!("{:x}", hasher.finalize());
-
-        if self.repo.find_by_hash(&hash).await?.is_some() {
-            return Err(CoreError::Duplicate(
-                "A file with this content already exists".to_string(),
-            ));
-        }
-
-        let now = chrono::Utc::now();
-        let year = now.year().to_string();
-        let month = format!("{:02}", now.month());
-        let mut dest_path = PathBuf::from(&self.config.media_library_path);
-        dest_path.push(year.clone());
-        dest_path.push(month.clone());
-
-        fs::create_dir_all(&dest_path)
-            .await
-            .map_err(|e| CoreError::Io(e))?;
-
-        dest_path.push(&data.filename);
-
-        let storage_path_str = PathBuf::from(&year)
-            .join(&month)
-            .join(&data.filename)
-            .to_string_lossy()
-            .to_string();
-
-        let mut file = fs::File::create(&dest_path)
-            .await
-            .map_err(|e| CoreError::Io(e))?;
-
-        file.write_all(&file_bytes)
-            .await
-            .map_err(|e| CoreError::Io(e))?;
-
-        let media_model = Media {
-            id: Uuid::new_v4(),
-            owner_id: data.owner_id,
-            storage_path: storage_path_str,
-            original_filename: data.filename,
-            mime_type: data.mime_type,
-            hash,
-            created_at: now,
-            extracted_location: None,
-            width: None,
-            height: None,
-        };
-
-        self.repo.create(&media_model).await?;
-        self.user_repo
-            .update_storage_used(user.id, file_size)
+        self.check_upload_prerequisites(owner_id, file_size, &hash)
             .await?;
 
-        let job_payload = json!({ "media_id": media_model.id });
-        self.nats_client
-            .publish("media.new".to_string(), job_payload.to_string().into())
-            .await
-            .map_err(|e| CoreError::Unknown(format!("Failed to publish NATS job: {}", e)))?;
+        let storage_path = self.persist_media_file(&file_bytes, &filename).await?;
 
-        Ok(media_model)
+        let media = self
+            .persist_media_metadata(owner_id, filename, mime_type, storage_path, hash, file_size)
+            .await?;
+
+        self.publish_new_media_job(media.id).await?;
+
+        Ok(media)
     }
 
     async fn get_media_details(&self, id: Uuid, user_id: Uuid) -> CoreResult<Media> {
@@ -235,3 +170,110 @@ impl MediaService for MediaServiceImpl {
         Ok(())
     }
 }
+
+impl MediaServiceImpl {
+    async fn hash_and_buffer_stream(
+        &self,
+        stream: &mut UploadMediaData<'_>,
+    ) -> CoreResult<(Vec<u8>, String, i64)> {
+        let mut hasher = Sha256::new();
+        let mut file_bytes = Vec::new();
+        while let Some(chunk_result) = stream.stream.next().await {
+            let chunk = chunk_result.map_err(|e| CoreError::Io(e))?;
+            hasher.update(&chunk);
+            file_bytes.extend_from_slice(&chunk);
+        }
+        let file_size = file_bytes.len() as i64;
+        let hash = format!("{:x}", hasher.finalize());
+        Ok((file_bytes, hash, file_size))
+    }
+
+    async fn check_upload_prerequisites(
+        &self,
+        user_id: Uuid,
+        file_size: i64,
+        hash: &str,
+    ) -> CoreResult<()> {
+        let user = self
+            .user_repo
+            .find_by_id(user_id)
+            .await?
+            .ok_or(CoreError::NotFound("User".to_string(), user_id))?;
+
+        if user.storage_used + file_size > user.storage_quota {
+            return Err(CoreError::Auth(format!(
+                "Storage quota exceeded. Used: {}, Quota: {}",
+                user.storage_used, user.storage_quota
+            )));
+        }
+
+        if self.repo.find_by_hash(hash).await?.is_some() {
+            return Err(CoreError::Duplicate(
+                "A file with this content already exists".to_string(),
+            ));
+        }
+
+        Ok(())
+    }
+
+    async fn persist_media_file(&self, file_bytes: &[u8], filename: &str) -> CoreResult<String> {
+        let now = chrono::Utc::now();
+        let year = now.year().to_string();
+        let month = format!("{:02}", now.month());
+        let mut dest_path = PathBuf::from(&self.config.media_library_path);
+        dest_path.push(year.clone());
+        dest_path.push(month.clone());
+
+        fs::create_dir_all(&dest_path).await?;
+        dest_path.push(filename);
+
+        let storage_path_str = PathBuf::from(&year)
+            .join(&month)
+            .join(filename)
+            .to_string_lossy()
+            .to_string();
+
+        let mut file = fs::File::create(&dest_path).await?;
+        file.write_all(&file_bytes).await?;
+
+        Ok(storage_path_str)
+    }
+
+    async fn persist_media_metadata(
+        &self,
+        owner_id: Uuid,
+        filename: String,
+        mime_type: String,
+        storage_path: String,
+        hash: String,
+        file_size: i64,
+    ) -> CoreResult<Media> {
+        let media_model = Media {
+            id: Uuid::new_v4(),
+            owner_id,
+            storage_path,
+            original_filename: filename,
+            mime_type,
+            hash,
+            created_at: chrono::Utc::now(),
+            extracted_location: None,
+            width: None,
+            height: None,
+        };
+
+        self.repo.create(&media_model).await?;
+        self.user_repo
+            .update_storage_used(owner_id, file_size)
+            .await?;
+
+        Ok(media_model)
+    }
+
+    async fn publish_new_media_job(&self, media_id: Uuid) -> CoreResult<()> {
+        let job_payload = json!({ "media_id": media_id });
+        self.nats_client
+            .publish("media.new".to_string(), job_payload.to_string().into())
+            .await
+            .map_err(|e| CoreError::Unknown(format!("Failed to publish NATS job: {}", e)))
+    }
+}

libertas_api/src/services/user_service.rs

@@ -2,6 +2,7 @@ use std::sync::Arc;
 
 use async_trait::async_trait;
 use libertas_core::{
+    config::Config,
     error::{CoreError, CoreResult},
     models::{Role, User},
     repositories::UserRepository,
@@ -16,6 +17,7 @@ pub struct UserServiceImpl {
     repo: Arc<dyn UserRepository>,
     hasher: Arc<dyn PasswordHasher>,
     tokenizer: Arc<dyn TokenGenerator>,
+    config: Arc<Config>,
 }
 
 impl UserServiceImpl {
@@ -23,11 +25,13 @@ impl UserServiceImpl {
         repo: Arc<dyn UserRepository>,
         hasher: Arc<dyn PasswordHasher>,
         tokenizer: Arc<dyn TokenGenerator>,
+        config: Arc<Config>,
     ) -> Self {
         Self {
             repo,
             hasher,
             tokenizer,
+            config,
         }
     }
 }
@@ -50,6 +54,9 @@ impl UserService for UserServiceImpl {
 
         let hashed_password = self.hasher.hash_password(data.password).await?;
 
+        let quota_gb = self.config.default_storage_quota_gb.unwrap_or(10);
+        let storage_quota = (quota_gb * 1024 * 1024 * 1024) as i64;
+
         let user = User {
             id: Uuid::new_v4(),
             username: data.username.to_string(),
@@ -58,7 +65,7 @@ impl UserService for UserServiceImpl {
             created_at: chrono::Utc::now(),
             updated_at: chrono::Utc::now(),
             role: Role::User,
-            storage_quota: 10 * 1024 * 1024 * 1024, // 10 GB
+            storage_quota,
             storage_used: 0,
         };