feat: add default storage quota configuration and update media upload handling

libertas_infra/src/repositories/album_share_repository.rs

@@ -35,7 +35,7 @@ impl AlbumShareRepository for PostgresAlbumShareRepository {
             "#,
             album_id,
             user_id,
-            permission as AlbumPermission,
+            permission.as_str() as "album_permission"
         )
         .execute(&self.pool)
         .await
@@ -49,12 +49,9 @@ impl AlbumShareRepository for PostgresAlbumShareRepository {
         album_id: Uuid,
         user_id: Uuid,
     ) -> CoreResult<Option<AlbumPermission>> {
-        let result = sqlx::query!(
-            r#"
-            SELECT permission as "permission: AlbumPermission"
-            FROM album_shares
-            WHERE album_id = $1 AND user_id = $2
-            "#,
+        let row = sqlx::query!(
+            // --- FIX 2: CAST the enum to TEXT in the SQL ---
+            "SELECT permission::TEXT as permission FROM album_shares WHERE album_id = $1 AND user_id = $2",
             album_id,
             user_id
         )
@@ -62,7 +59,8 @@ impl AlbumShareRepository for PostgresAlbumShareRepository {
         .await
         .map_err(|e| CoreError::Database(e.to_string()))?;
 
-        Ok(result.map(|row| row.permission))
+        // This now works because r.permission is a String
+        Ok(row.map(|r| AlbumPermission::from(r.permission.as_str())))
     }
 
     async fn is_media_in_shared_album(&self, media_id: Uuid, user_id: Uuid) -> CoreResult<bool> {

libertas_infra/src/repositories/user_repository.rs

@@ -54,57 +54,69 @@ impl UserRepository for PostgresUserRepository {
     }
 
     async fn find_by_email(&self, email: &str) -> CoreResult<Option<User>> {
-        sqlx::query_as!(
-            User,
-            r#"
-            SELECT 
-                id, username, email, hashed_password, created_at, updated_at,
-                role as "role: Role", 
-                storage_quota, storage_used
-            FROM users 
-            WHERE email = $1
-            "#,
+        let row = sqlx::query!(
+            r#"SELECT id, username, email, hashed_password, created_at, updated_at, role, storage_quota, storage_used FROM users WHERE email = $1"#,
             email
         )
         .fetch_optional(&self.pool)
         .await
-        .map_err(|e| CoreError::Database(e.to_string()))
+        .map_err(|e| CoreError::Database(e.to_string()))?;
+
+        Ok(row.map(|r| User {
+            id: r.id,
+            username: r.username,
+            email: r.email,
+            hashed_password: r.hashed_password,
+            created_at: r.created_at,
+            updated_at: r.updated_at,
+            role: Role::from(r.role.as_str()),
+            storage_quota: r.storage_quota,
+            storage_used: r.storage_used,
+        }))
     }
 
     async fn find_by_username(&self, username: &str) -> CoreResult<Option<User>> {
-        sqlx::query_as!(
-            User,
-            r#"
-            SELECT 
-                id, username, email, hashed_password, created_at, updated_at,
-                role as "role: Role",
-                storage_quota, storage_used
-            FROM users 
-            WHERE username = $1
-            "#,
+        let row = sqlx::query!(
+            r#"SELECT id, username, email, hashed_password, created_at, updated_at, role, storage_quota, storage_used FROM users WHERE username = $1"#,
             username
         )
         .fetch_optional(&self.pool)
         .await
-        .map_err(|e| CoreError::Database(e.to_string()))
+        .map_err(|e| CoreError::Database(e.to_string()))?;
+
+        Ok(row.map(|r| User {
+            id: r.id,
+            username: r.username,
+            email: r.email,
+            hashed_password: r.hashed_password,
+            created_at: r.created_at,
+            updated_at: r.updated_at,
+            role: Role::from(r.role.as_str()),
+            storage_quota: r.storage_quota,
+            storage_used: r.storage_used,
+        }))
     }
 
     async fn find_by_id(&self, id: Uuid) -> CoreResult<Option<User>> {
-        sqlx::query_as!(
-            User,
-            r#"
-            SELECT 
-                id, username, email, hashed_password, created_at, updated_at,
-                role as "role: Role",
-                storage_quota, storage_used
-            FROM users 
-            WHERE id = $1
-            "#,
+        let row = sqlx::query!(
+            r#"SELECT id, username, email, hashed_password, created_at, updated_at, role, storage_quota, storage_used FROM users WHERE id = $1"#,
             id
         )
         .fetch_optional(&self.pool)
         .await
-        .map_err(|e| CoreError::Database(e.to_string()))
+        .map_err(|e| CoreError::Database(e.to_string()))?;
+
+        Ok(row.map(|r| User {
+            id: r.id,
+            username: r.username,
+            email: r.email,
+            hashed_password: r.hashed_password,
+            created_at: r.created_at,
+            updated_at: r.updated_at,
+            role: Role::from(r.role.as_str()),
+            storage_quota: r.storage_quota,
+            storage_used: r.storage_used,
+        }))
     }
 
     async fn update_storage_used(&self, user_id: Uuid, bytes: i64) -> CoreResult<()> {