feat: Implement media import functionality with repository and bundle support

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)
     }