style: apply rustfmt formatting to fix CI

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

src/application/services/admin_settings_service.rs

@@ -384,10 +384,7 @@ impl AdminSettingsService {
     /// initialized (the caller "won" the race), or `Ok(false)` if another
     /// request already did it.  This eliminates the race-condition window
     /// between `is_system_initialized()` and `mark_system_initialized()`.
-    pub async fn try_claim_initialization(
-        &self,
-        admin_user_id: &str,
-    ) -> Result<bool, DomainError> {
+    pub async fn try_claim_initialization(&self, admin_user_id: &str) -> Result<bool, DomainError> {
         self.settings_repo
             .try_claim_initialization(admin_user_id)
             .await

src/application/services/batch_operations.rs

@@ -682,7 +682,11 @@ impl BatchOperationService {
 
         // ── Add folders as sub-trees (bulk subtree queries, not N+1) ─────
         for folder_id in &folder_ids {
-            match self.folder_service.get_folder_owned(folder_id, caller_id).await {
+            match self
+                .folder_service
+                .get_folder_owned(folder_id, caller_id)
+                .await
+            {
                 Ok(root_folder) => {
                     if let Err(e) = self
                         .add_folder_subtree_to_zip(&mut zip, folder_id, &root_folder, caller_id)
@@ -928,7 +932,9 @@ impl BatchOperationService {
 
             async move {
                 // If a parent is specified, verify the caller owns it
-                if let Some(ref pid) = parent_id && let Err(e) = folder_service.get_folder_owned(pid, &caller).await {
+                if let Some(ref pid) = parent_id
+                    && let Err(e) = folder_service.get_folder_owned(pid, &caller).await
+                {
                     let id = format!("{}:{}", name, pid);
                     return (id, Err(e));
                 }

src/application/services/file_retrieval_service.rs

@@ -228,7 +228,10 @@ impl FileRetrievalUseCase for FileRetrievalService {
         folder_id: Option<&str>,
         owner_id: &str,
     ) -> Result<Vec<FileDto>, DomainError> {
-        let files = self.file_read.list_files_for_owner(folder_id, owner_id).await?;
+        let files = self
+            .file_read
+            .list_files_for_owner(folder_id, owner_id)
+            .await?;
         Ok(files.into_iter().map(FileDto::from).collect())
     }
 

src/application/services/folder_service.rs

@@ -32,7 +32,11 @@ impl FolderService {
                 Ok(FolderDto::empty())
             }
 
-            async fn get_folder_owned(&self, _id: &str, _caller_id: &str) -> Result<FolderDto, DomainError> {
+            async fn get_folder_owned(
+                &self,
+                _id: &str,
+                _caller_id: &str,
+            ) -> Result<FolderDto, DomainError> {
                 Ok(FolderDto::empty())
             }
 

src/application/services/share_service.rs

@@ -20,7 +20,10 @@ use crate::{
             storage_ports::FileReadPort,
         },
     },
-    common::{config::AppConfig, errors::{DomainError, ErrorKind}},
+    common::{
+        config::AppConfig,
+        errors::{DomainError, ErrorKind},
+    },
     domain::entities::share::{Share, ShareItemType, SharePermissions},
 };
 
@@ -147,11 +150,7 @@ impl ShareService {
     /// but belongs to a different user — this prevents share-ID enumeration
     /// attacks where an attacker probes IDs and uses 403-vs-404 to learn
     /// which ones are valid.
-    async fn fetch_owned_share(
-        &self,
-        id: &str,
-        requester_id: &str,
-    ) -> Result<Share, DomainError> {
+    async fn fetch_owned_share(&self, id: &str, requester_id: &str) -> Result<Share, DomainError> {
         let share = self
             .share_repository
             .find_share_by_id_for_user(id, requester_id)
@@ -206,11 +205,7 @@ impl ShareUseCase for ShareService {
         Ok(ShareDto::from_entity(&saved_share, &self.config.base_url()))
     }
 
-    async fn get_shared_link(
-        &self,
-        id: &str,
-        requester_id: &str,
-    ) -> Result<ShareDto, DomainError> {
+    async fn get_shared_link(&self, id: &str, requester_id: &str) -> Result<ShareDto, DomainError> {
         // SECURITY: ownership-verified lookup — returns 404 if the share
         // doesn't exist OR belongs to another user.
         let share = self.fetch_owned_share(id, requester_id).await?;
@@ -553,7 +548,11 @@ mod tests {
             Ok(ShareDto::from_entity(&saved_share, &self.config.base_url()))
         }
 
-        async fn get_shared_link(&self, id: &str, requester_id: &str) -> Result<ShareDto, DomainError> {
+        async fn get_shared_link(
+            &self,
+            id: &str,
+            requester_id: &str,
+        ) -> Result<ShareDto, DomainError> {
             let share = self
                 .share_repository
                 .find_share_by_id_for_user(id, requester_id)
@@ -634,7 +633,11 @@ mod tests {
             Ok(ShareDto::from_entity(&updated, &self.config.base_url()))
         }
 
-        async fn delete_shared_link(&self, id: &str, requester_id: &str) -> Result<(), DomainError> {
+        async fn delete_shared_link(
+            &self,
+            id: &str,
+            requester_id: &str,
+        ) -> Result<(), DomainError> {
             self.share_repository
                 .delete_share_for_user(id, requester_id)
                 .await

src/application/services/trash_service.rs

@@ -186,7 +186,11 @@ impl TrashUseCase for TrashService {
                 // Returns NotFound if the file does not exist OR belongs to
                 // another user, preventing cross-user trash operations.
                 debug!("Getting file data (owner-scoped): {}", item_id);
-                let file = match self.file_read_port.get_file_for_owner(item_id, user_id).await {
+                let file = match self
+                    .file_read_port
+                    .get_file_for_owner(item_id, user_id)
+                    .await
+                {
                     Ok(file) => {
                         debug!("File found: {} ({})", file.name(), item_id);
                         file