feat: Implement media import functionality with repository and bundle support

libertas_infra/src/repositories/media_import_repository.rs

@@ -0,0 +1,57 @@
+use async_trait::async_trait;
+use libertas_core::{
+    error::{CoreError, CoreResult},
+    repositories::MediaImportRepository,
+    schema::MediaImportBundle,
+};
+use sqlx::PgPool;
+
+use crate::repositories::{
+    media_metadata_repository::PostgresMediaMetadataRepository,
+    media_repository::PostgresMediaRepository, user_repository::PostgresUserRepository,
+};
+
+#[derive(Clone)]
+pub struct PostgresMediaImportRepository {
+    pool: PgPool,
+}
+
+impl PostgresMediaImportRepository {
+    pub fn new(pool: PgPool) -> Self {
+        Self { pool }
+    }
+}
+
+#[async_trait]
+impl MediaImportRepository for PostgresMediaImportRepository {
+    async fn create_media_bundle(&self, bundle: MediaImportBundle) -> CoreResult<()> {
+        let mut tx = self
+            .pool
+            .begin()
+            .await
+            .map_err(|e| CoreError::Database(e.to_string()))?;
+
+        PostgresMediaRepository::create_internal(&mut *tx, &bundle.media_model).await?;
+
+        if !bundle.metadata_models.is_empty() {
+            PostgresMediaMetadataRepository::create_batch_internal(
+                &mut *tx,
+                &bundle.metadata_models,
+            )
+            .await?;
+        }
+
+        PostgresUserRepository::update_storage_used_internal(
+            &mut *tx,
+            bundle.media_model.owner_id,
+            bundle.file_size as i64,
+        )
+        .await?;
+
+        tx.commit()
+            .await
+            .map_err(|e| CoreError::Database(e.to_string()))?;
+
+        Ok(())
+    }
+}

libertas_infra/src/repositories/media_metadata_repository.rs

@@ -1,5 +1,9 @@
 use async_trait::async_trait;
-use libertas_core::{error::{CoreError, CoreResult}, models::MediaMetadata, repositories::MediaMetadataRepository};
+use libertas_core::{
+    error::{CoreError, CoreResult},
+    models::MediaMetadata,
+    repositories::MediaMetadataRepository,
+};
 use sqlx::PgPool;
 
 use crate::db_models::{PostgresMediaMetadata, PostgresMediaMetadataSource};
@@ -12,11 +16,11 @@ impl PostgresMediaMetadataRepository {
     pub fn new(pool: PgPool) -> Self {
         Self { pool }
     }
-}
 
-#[async_trait]
-impl MediaMetadataRepository for PostgresMediaMetadataRepository {
-    async fn create_batch(&self, metadata: &[MediaMetadata]) -> CoreResult<()> {
+    pub(crate) async fn create_batch_internal<'a>(
+        exec: impl sqlx::Executor<'a, Database = sqlx::Postgres>,
+        metadata: &[MediaMetadata],
+    ) -> CoreResult<()> {
         if metadata.is_empty() {
             return Ok(());
         }
@@ -52,12 +56,19 @@ impl MediaMetadataRepository for PostgresMediaMetadataRepository {
             &tag_names,
             &tag_values,
         )
-        .execute(&self.pool)
+        .execute(exec)
         .await
         .map_err(|e| CoreError::Database(e.to_string()))?;
 
         Ok(())
     }
+}
+
+#[async_trait]
+impl MediaMetadataRepository for PostgresMediaMetadataRepository {
+    async fn create_batch(&self, metadata: &[MediaMetadata]) -> CoreResult<()> {
+        Self::create_batch_internal(&self.pool, metadata).await
+    }
 
     async fn find_by_media_id(&self, media_id: uuid::Uuid) -> CoreResult<Vec<MediaMetadata>> {
         let pg_metadata = sqlx::query_as!(
@@ -76,4 +87,4 @@ impl MediaMetadataRepository for PostgresMediaMetadataRepository {
         let metadata = pg_metadata.into_iter().map(|m| m.into()).collect();
         Ok(metadata)
     }
-}
+}

libertas_infra/src/repositories/media_repository.rs

@@ -2,12 +2,19 @@ use std::sync::Arc;
 
 use async_trait::async_trait;
 use libertas_core::{
-    config::AppConfig, error::{CoreError, CoreResult}, models::Media, repositories::MediaRepository, schema::ListMediaOptions
+    config::AppConfig,
+    error::{CoreError, CoreResult},
+    models::Media,
+    repositories::MediaRepository,
+    schema::ListMediaOptions,
 };
 use sqlx::PgPool;
 use uuid::Uuid;
 
-use crate::{db_models::PostgresMedia, query_builder::{MediaQueryBuilder, QueryBuilder}};
+use crate::{
+    db_models::PostgresMedia,
+    query_builder::{MediaQueryBuilder, QueryBuilder},
+};
 
 #[derive(Clone)]
 pub struct PostgresMediaRepository {
@@ -22,13 +29,16 @@ impl PostgresMediaRepository {
             .clone()
             .unwrap_or_else(|| vec!["created_at".to_string(), "original_filename".to_string()]);
 
-        Self { pool, query_builder: Arc::new(MediaQueryBuilder::new(allowed_columns)) }
+        Self {
+            pool,
+            query_builder: Arc::new(MediaQueryBuilder::new(allowed_columns)),
+        }
     }
-}
 
-#[async_trait]
-impl MediaRepository for PostgresMediaRepository {
-    async fn create(&self, media: &Media) -> CoreResult<()> {
+    pub(crate) async fn create_internal<'a>(
+        exec: impl sqlx::Executor<'a, Database = sqlx::Postgres>,
+        media: &Media,
+    ) -> CoreResult<()> {
         sqlx::query!(
             r#"
             INSERT INTO media (id, owner_id, storage_path, original_filename, mime_type, hash, created_at, thumbnail_path)
@@ -43,12 +53,18 @@ impl MediaRepository for PostgresMediaRepository {
             media.created_at,
             media.thumbnail_path
         )
-        .execute(&self.pool)
+        .execute(exec)
         .await
         .map_err(|e| CoreError::Database(e.to_string()))?;
-
         Ok(())
     }
+}
+
+#[async_trait]
+impl MediaRepository for PostgresMediaRepository {
+    async fn create(&self, media: &Media) -> CoreResult<()> {
+        Self::create_internal(&self.pool, media).await
+    }
 
     async fn find_by_hash(&self, hash: &str) -> CoreResult<Option<Media>> {
         let pg_media = sqlx::query_as!(
@@ -86,7 +102,11 @@ impl MediaRepository for PostgresMediaRepository {
         Ok(pg_media.map(|m| m.into()))
     }
 
-    async fn list_by_user(&self, user_id: Uuid, options: &ListMediaOptions) -> CoreResult<Vec<Media>> {
+    async fn list_by_user(
+        &self,
+        user_id: Uuid,
+        options: &ListMediaOptions,
+    ) -> CoreResult<Vec<Media>> {
         let mut query = sqlx::QueryBuilder::new(
             r#"
             SELECT media.id, media.owner_id, media.storage_path, media.original_filename, media.mime_type, media.hash, media.created_at, 
@@ -98,16 +118,14 @@ impl MediaRepository for PostgresMediaRepository {
 
         query.push_bind(user_id);
 
-        query = self
-            .query_builder
-            .apply_options_to_query(query, options)?;
+        query = self.query_builder.apply_options_to_query(query, options)?;
 
         let pg_media = query
-        .build_query_as::<PostgresMedia>()
-        .fetch_all(&self.pool)
-        .await
-        .map_err(|e| CoreError::Database(e.to_string()))?;
-        
+            .build_query_as::<PostgresMedia>()
+            .fetch_all(&self.pool)
+            .await
+            .map_err(|e| CoreError::Database(e.to_string()))?;
+
         let media_list = pg_media.into_iter().map(|m| m.into()).collect();
         Ok(media_list)
     }

libertas_infra/src/repositories/mod.rs

@@ -1,9 +1,10 @@
 pub mod album_repository;
 pub mod album_share_repository;
-pub mod media_repository;
-pub mod user_repository;
-pub mod media_metadata_repository;
-pub mod tag_repository;
-pub mod person_repository;
 pub mod face_region_repository;
-pub mod person_share_repository;
+pub mod media_import_repository;
+pub mod media_metadata_repository;
+pub mod media_repository;
+pub mod person_repository;
+pub mod person_share_repository;
+pub mod tag_repository;
+pub mod user_repository;

libertas_infra/src/repositories/user_repository.rs

@@ -4,7 +4,7 @@ use libertas_core::{
     models::User,
     repositories::UserRepository,
 };
-use sqlx::{PgPool, SqlitePool, types::Uuid};
+use sqlx::{Executor, PgPool, Postgres, SqlitePool, types::Uuid};
 
 use crate::db_models::PostgresUser;
 
@@ -17,6 +17,27 @@ impl PostgresUserRepository {
     pub fn new(pool: PgPool) -> Self {
         Self { pool }
     }
+
+    pub(crate) async fn update_storage_used_internal<'a>(
+        exec: impl Executor<'a, Database = Postgres>,
+        user_id: Uuid,
+        bytes: i64,
+    ) -> CoreResult<()> {
+        sqlx::query!(
+            r#"
+            UPDATE users
+            SET storage_used = storage_used + $1, updated_at = NOW()
+            WHERE id = $2
+            "#,
+            bytes,
+            user_id
+        )
+        .execute(exec)
+        .await
+        .map_err(|e| CoreError::Database(e.to_string()))?;
+
+        Ok(())
+    }
 }
 
 #[derive(Clone)]
@@ -114,20 +135,7 @@ impl UserRepository for PostgresUserRepository {
     }
 
     async fn update_storage_used(&self, user_id: Uuid, bytes: i64) -> CoreResult<()> {
-        sqlx::query!(
-            r#"
-            UPDATE users
-            SET storage_used = storage_used + $1, updated_at = NOW()
-            WHERE id = $2
-            "#,
-            bytes,
-            user_id
-        )
-        .execute(&self.pool)
-        .await
-        .map_err(|e| CoreError::Database(e.to_string()))?;
-
-        Ok(())
+        Self::update_storage_used_internal(&self.pool, user_id, bytes).await
     }
 }