Merge pull request #157 from DioCrafts/claude/optimize-performance-XMWwR

Remove async-trait dependency and use concrete types

Cargo.lock

@@ -129,17 +129,6 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "async-trait"
-version = "0.1.89"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9035ad2d096bed7955a320ee7e2230574d28fd3c3a0f186cbea1ff3c7eed5dbb"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn",
-]
-
 [[package]]
 name = "async_zip"
 version = "0.0.18"
@@ -1819,7 +1808,6 @@ dependencies = [
  "argon2",
  "async-compression",
  "async-stream",
- "async-trait",
  "async_zip",
  "axum",
  "base64",

Cargo.toml

@@ -26,7 +26,6 @@ futures = "0.3.32"
 async-stream = "0.3.6"
 mime_guess = "2.0.5"
 uuid = { version = "1.21.0", features = ["v4", "serde"] }
-async-trait = "0.1.89"
 thiserror = "2.0.18"
 mockall = { version = "0.14.0", optional = true }
 sqlx = { version = "0.8.6", features = ["postgres", "runtime-tokio", "tls-rustls", "chrono", "uuid", "json"] }

src/application/ports/auth_ports.rs

@@ -3,7 +3,6 @@ use crate::domain::entities::app_password::AppPassword;
 use crate::domain::entities::device_code::DeviceCode;
 use crate::domain::entities::session::Session;
 use crate::domain::entities::user::User;
-use async_trait::async_trait;
 
 // ============================================================================
 // Cryptography Ports - Extracted from Domain to maintain Clean Architecture
@@ -16,7 +15,6 @@ use async_trait::async_trait;
 ///
 /// Methods are async because implementations (e.g. Argon2) are CPU-intensive
 /// and must run on a blocking thread pool to avoid starving Tokio workers.
-#[async_trait]
 pub trait PasswordHasherPort: Send + Sync + 'static {
     /// Hash a plain text password
     async fn hash_password(&self, password: &str) -> Result<String, DomainError>;
@@ -69,7 +67,6 @@ pub trait TokenServicePort: Send + Sync + 'static {
 // Storage Ports
 // ============================================================================
 
-#[async_trait]
 pub trait UserStoragePort: Send + Sync + 'static {
     /// Creates a new user
     async fn create_user(&self, user: User) -> Result<User, DomainError>;
@@ -153,7 +150,6 @@ pub struct OidcIdClaims {
 }
 
 /// Port for OIDC operations — implemented in infrastructure layer
-#[async_trait]
 pub trait OidcServicePort: Send + Sync + 'static {
     /// Get the authorization URL for redirecting the user to the IdP.
     /// Includes PKCE code_challenge (S256) and nonce for ID token binding.
@@ -187,7 +183,6 @@ pub trait OidcServicePort: Send + Sync + 'static {
     fn provider_name(&self) -> &str;
 }
 
-#[async_trait]
 pub trait SessionStoragePort: Send + Sync + 'static {
     /// Creates a new session
     async fn create_session(&self, session: Session) -> Result<Session, DomainError>;
@@ -209,7 +204,6 @@ pub trait SessionStoragePort: Send + Sync + 'static {
 // Device Authorization Grant Port (RFC 8628)
 // ============================================================================
 
-#[async_trait]
 pub trait DeviceCodeStoragePort: Send + Sync + 'static {
     /// Persist a new device code flow
     async fn create_device_code(&self, device_code: DeviceCode) -> Result<DeviceCode, DomainError>;
@@ -238,7 +232,6 @@ pub trait DeviceCodeStoragePort: Send + Sync + 'static {
 // ============================================================================
 
 /// Storage port for application-specific passwords (HTTP Basic Auth for DAV clients).
-#[async_trait]
 pub trait AppPasswordStoragePort: Send + Sync + 'static {
     /// Persist a new app password (hash already computed).
     async fn create(&self, app_password: AppPassword) -> Result<AppPassword, DomainError>;

src/application/ports/cache_ports.rs

@@ -9,7 +9,6 @@
 //! implementation details.
 
 use crate::common::errors::DomainError;
-use async_trait::async_trait;
 use bytes::Bytes;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
@@ -30,7 +29,6 @@ pub struct WriteBehindStatsDto {
 /// Provides deferred write semantics: small files are held in memory
 /// and the response is returned immediately, while actual disk writes
 /// happen asynchronously in the background.
-#[async_trait]
 pub trait WriteBehindCachePort: Send + Sync + 'static {
     /// Check if a file size is eligible for write-behind caching.
     fn is_eligible_size(&self, size: usize) -> bool;
@@ -82,7 +80,6 @@ pub struct CachedMetadataDto {
 ///
 /// Provides fast lookups for existence, size, timestamps and MIME types
 /// without hitting the filesystem on every request.
-#[async_trait]
 pub trait MetadataCachePort: Send + Sync + 'static {
     /// Get cached metadata for a path, or `None` on miss / expired.
     async fn get_metadata(&self, path: &Path) -> Option<CachedMetadataDto>;
@@ -106,7 +103,6 @@ pub trait MetadataCachePort: Send + Sync + 'static {
 ///
 /// Implementations should use LRU eviction and respect size limits so that
 /// the application layer never needs to know the concrete cache type.
-#[async_trait]
 pub trait ContentCachePort: Send + Sync + 'static {
     /// Check whether a file of the given size should be cached.
     fn should_cache(&self, size: usize) -> bool;

src/application/ports/calendar_ports.rs

@@ -3,11 +3,9 @@ use crate::application::dtos::calendar_dto::{
     UpdateCalendarDto, UpdateEventDto,
 };
 use crate::common::errors::DomainError;
-use async_trait::async_trait;
 use chrono::{DateTime, Utc};
 
 /// Port for external calendar storage mechanisms
-#[async_trait]
 pub trait CalendarStoragePort: Send + Sync + 'static {
     // Calendar operations
     async fn create_calendar(
@@ -111,7 +109,6 @@ pub trait CalendarStoragePort: Send + Sync + 'static {
 /// All methods require an explicit `user_id` parameter for authorization.
 /// The CalDAV protocol handler extracts the user identity from JWT claims
 /// and passes it through.
-#[async_trait]
 pub trait CalendarUseCase: Send + Sync + 'static {
     // Calendar operations
     async fn create_calendar(

src/application/ports/carddav_ports.rs

@@ -7,11 +7,9 @@ use crate::application::dtos::contact_dto::{
     GroupMembershipDto, UpdateContactDto, UpdateContactGroupDto,
 };
 use crate::common::errors::DomainError;
-use async_trait::async_trait;
 
 pub type CardDavRepositoryError = DomainError;
 
-#[async_trait]
 pub trait AddressBookUseCase: Send + Sync + 'static {
     // Address Book operations
     async fn create_address_book(
@@ -57,7 +55,6 @@ pub trait AddressBookUseCase: Send + Sync + 'static {
     ) -> Result<Vec<(String, bool)>, DomainError>;
 }
 
-#[async_trait]
 pub trait ContactUseCase: Send + Sync + 'static {
     // Contact operations
     async fn create_contact(&self, dto: CreateContactDto) -> Result<ContactDto, DomainError>;

src/application/ports/chunked_upload_ports.rs

@@ -5,7 +5,6 @@
 //! the specific upload implementation (TUS-like protocol, S3 multipart, etc.).
 
 use crate::common::errors::DomainError;
-use async_trait::async_trait;
 use bytes::Bytes;
 use serde::Serialize;
 use std::path::PathBuf;
@@ -53,7 +52,6 @@ pub struct UploadStatusResponseDto {
 /// Implementations manage upload sessions, chunk storage, reassembly,
 /// and cleanup, while the application layer only interacts through
 /// this abstraction.
-#[async_trait]
 pub trait ChunkedUploadPort: Send + Sync + 'static {
     /// Create a new upload session.
     ///

src/application/ports/compression_ports.rs

@@ -5,7 +5,6 @@
 //! compression implementations (gzip, zstd, etc.).
 
 use crate::common::errors::DomainError;
-use async_trait::async_trait;
 
 /// Compression level settings for file compression operations.
 ///
@@ -27,7 +26,6 @@ pub enum CompressionLevel {
 /// Implementations of this trait provide the actual compression logic
 /// (e.g., gzip, zstd) while the application layer remains agnostic
 /// of the specific algorithm used.
-#[async_trait]
 pub trait CompressionPort: Send + Sync + 'static {
     /// Compress data in memory.
     async fn compress_data(

src/application/ports/dedup_ports.rs

@@ -5,7 +5,6 @@
 //! content-addressable storage implementation.
 
 use crate::common::errors::DomainError;
-use async_trait::async_trait;
 use bytes::Bytes;
 use futures::Stream;
 use serde::Serialize;
@@ -92,7 +91,6 @@ pub struct DedupStatsDto {
 /// Implementations store files by their content hash, eliminating
 /// duplicate storage automatically. Multiple file references can
 /// point to the same physical blob.
-#[async_trait]
 pub trait DedupPort: Send + Sync + 'static {
     /// Store content with deduplication (from bytes).
     ///

src/application/ports/favorites_ports.rs

@@ -1,9 +1,7 @@
 use crate::application::dtos::favorites_dto::{BatchFavoritesResult, FavoriteItemDto};
 use crate::common::errors::Result;
-use async_trait::async_trait;
 
 /// Defines operations for managing user favorites
-#[async_trait]
 pub trait FavoritesUseCase: Send + Sync {
     /// Get all favorites for a user
     async fn get_favorites(&self, user_id: &str) -> Result<Vec<FavoriteItemDto>>;
@@ -40,7 +38,6 @@ pub trait FavoritesUseCase: Send + Sync {
 /// Application services depend on this trait instead of
 /// accessing `PgPool` directly. The concrete implementation
 /// lives in `infrastructure::repositories::pg`.
-#[async_trait]
 pub trait FavoritesRepositoryPort: Send + Sync + 'static {
     /// Gets all favorites for a user.
     async fn get_favorites(&self, user_id: &str) -> Result<Vec<FavoriteItemDto>>;

src/application/ports/file_ports.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use bytes::Bytes;
 use futures::Stream;
 use std::path::Path;
@@ -8,6 +7,9 @@ use std::sync::Arc;
 use crate::application::dtos::file_dto::FileDto;
 use crate::application::ports::storage_ports::CopyFolderTreeResult;
 use crate::common::errors::DomainError;
+use crate::application::services::file_management_service::FileManagementService;
+use crate::application::services::file_retrieval_service::FileRetrievalService;
+use crate::application::services::file_upload_service::FileUploadService;
 
 // ─────────────────────────────────────────────────────
 // Upload port
@@ -24,7 +26,6 @@ use crate::common::errors::DomainError;
 /// - Chunked uploads: chunks already on disk → `upload_file_from_path`
 /// - WebDAV PUT (new): handler streams to temp file → `update_file_streaming`
 /// - WebDAV PUT (small/compat): `create_file` / `update_file` spool internally
-#[async_trait]
 pub trait FileUploadUseCase: Send + Sync + 'static {
     /// Upload from a temp file already on disk (true streaming, ~256 KB RAM).
     ///
@@ -102,7 +103,6 @@ pub enum OptimizedFileContent {
 }
 
 /// Primary port for file retrieval operations
-#[async_trait]
 pub trait FileRetrievalUseCase: Send + Sync + 'static {
     /// Gets a file by its ID
     async fn get_file(&self, id: &str) -> Result<FileDto, DomainError>;
@@ -188,7 +188,6 @@ pub trait FileRetrievalUseCase: Send + Sync + 'static {
 // ─────────────────────────────────────────────────────
 
 /// Primary port for file management operations
-#[async_trait]
 pub trait FileManagementUseCase: Send + Sync + 'static {
     /// Moves a file to another folder
     async fn move_file(
@@ -241,7 +240,7 @@ pub trait FileManagementUseCase: Send + Sync + 'static {
 
 /// Factory for creating file use case implementations
 pub trait FileUseCaseFactory: Send + Sync + 'static {
-    fn create_file_upload_use_case(&self) -> Arc<dyn FileUploadUseCase>;
-    fn create_file_retrieval_use_case(&self) -> Arc<dyn FileRetrievalUseCase>;
-    fn create_file_management_use_case(&self) -> Arc<dyn FileManagementUseCase>;
+    fn create_file_upload_use_case(&self) -> Arc<FileUploadService>;
+    fn create_file_retrieval_use_case(&self) -> Arc<FileRetrievalService>;
+    fn create_file_management_use_case(&self) -> Arc<FileManagementService>;
 }

src/application/ports/inbound.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use std::sync::Arc;
 
 use crate::application::dtos::folder_dto::{
@@ -10,7 +9,6 @@ use crate::application::dtos::search_dto::{
 use crate::common::errors::DomainError;
 
 /// Primary port for folder operations
-#[async_trait]
 pub trait FolderUseCase: Send + Sync + 'static {
     /// Creates a new folder
     async fn create_folder(&self, dto: CreateFolderDto) -> Result<FolderDto, DomainError>;
@@ -89,7 +87,6 @@ pub trait FolderUseCase: Send + Sync + 'static {
  * All search processing (filtering, scoring, sorting, categorization)
  * is handled server-side in Rust for maximum efficiency.
  */
-#[async_trait]
 pub trait SearchUseCase: Send + Sync + 'static {
     /// Performs a full search based on the specified criteria.
     ///

src/application/ports/outbound.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use std::path::PathBuf;
 
 use crate::common::errors::DomainError;
@@ -10,7 +9,6 @@ pub use crate::domain::repositories::folder_repository::FolderRepository;
 use super::storage_ports::{FileReadPort, FileWritePort};
 
 /// Secondary port for storage operations
-#[async_trait]
 pub trait StoragePort: Send + Sync + 'static {
     /// Resolves a domain path to a physical path
     fn resolve_path(&self, storage_path: &StoragePath) -> PathBuf;

src/application/ports/recent_ports.rs

@@ -1,9 +1,7 @@
 use crate::application::dtos::recent_dto::RecentItemDto;
 use crate::common::errors::Result;
-use async_trait::async_trait;
 
 /// Defines operations for managing user recent items
-#[async_trait]
 pub trait RecentItemsUseCase: Send + Sync {
     /// Get all recent items for a user
     async fn get_recent_items(
@@ -36,7 +34,6 @@ pub trait RecentItemsUseCase: Send + Sync {
 ///
 /// Abstracts access to the `auth.user_recent_files` table so that
 /// `RecentService` does not depend directly on `PgPool`.
-#[async_trait]
 pub trait RecentItemsRepositoryPort: Send + Sync + 'static {
     /// Gets the latest recent items for a user (ordered by date desc).
     async fn get_recent_items(&self, user_id: &str, limit: i32) -> Result<Vec<RecentItemDto>>;

src/application/ports/share_ports.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 
 use crate::{
     application::dtos::{
@@ -9,7 +8,6 @@ use crate::{
     domain::entities::share::ShareItemType,
 };
 
-#[async_trait]
 pub trait ShareUseCase: Send + Sync + 'static {
     /// Create a new shared link for a file or folder
     async fn create_shared_link(
@@ -60,7 +58,6 @@ pub trait ShareUseCase: Send + Sync + 'static {
     async fn register_shared_link_access(&self, token: &str) -> Result<(), DomainError>;
 }
 
-#[async_trait]
 pub trait ShareStoragePort: Send + Sync + 'static {
     async fn save_share(
         &self,

src/application/ports/storage_ports.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use bytes::Bytes;
 use futures::Stream;
 use serde_json::Value;
@@ -25,7 +24,6 @@ pub use crate::domain::repositories::folder_repository::FolderRepository;
 ///
 /// Encapsulates every operation that queries state without modifying it:
 /// get, list, content, stream, mmap, range, path resolution.
-#[async_trait]
 pub trait FileReadPort: Send + Sync + 'static {
     /// Gets a file by its ID.
     async fn get_file(&self, id: &str) -> Result<File, DomainError>;
@@ -199,7 +197,6 @@ pub struct CopyFolderTreeResult {
 ///
 /// Covers: upload (buffered + streaming), move, delete, update,
 /// and deferred registration for the write-behind cache.
-#[async_trait]
 pub trait FileWritePort: Send + Sync + 'static {
     /// Streaming upload — saves a file from a temp file already on disk.
     ///
@@ -307,7 +304,6 @@ pub trait FileWritePort: Send + Sync + 'static {
 // ─────────────────────────────────────────────────────
 
 /// Secondary port for file path resolution
-#[async_trait]
 pub trait FilePathResolutionPort: Send + Sync + 'static {
     /// Gets the storage path of a file
     async fn get_file_path(&self, id: &str) -> Result<StoragePath, DomainError>;
@@ -317,7 +313,6 @@ pub trait FilePathResolutionPort: Send + Sync + 'static {
 }
 
 /// Secondary port for file/directory existence verification
-#[async_trait]
 pub trait StorageVerificationPort: Send + Sync + 'static {
     /// Checks whether a file exists at the given path
     async fn file_exists(&self, storage_path: &StoragePath) -> Result<bool, DomainError>;
@@ -327,14 +322,12 @@ pub trait StorageVerificationPort: Send + Sync + 'static {
 }
 
 /// Secondary port for directory management
-#[async_trait]
 pub trait DirectoryManagementPort: Send + Sync + 'static {
     /// Creates directories if they do not exist
     async fn ensure_directory(&self, storage_path: &StoragePath) -> Result<(), DomainError>;
 }
 
 /// Secondary port for storage usage management
-#[async_trait]
 pub trait StorageUsagePort: Send + Sync + 'static {
     /// Updates storage usage statistics for a user
     async fn update_user_storage_usage(&self, user_id: &str) -> Result<i64, DomainError>;
@@ -362,7 +355,6 @@ pub trait StorageUsagePort: Send + Sync + 'static {
 }
 
 /// Generic storage service interface for calendar and contact services
-#[async_trait]
 pub trait StorageUseCase: Send + Sync + 'static {
     /// Handle a request with the specified action and parameters
     async fn handle_request(&self, action: &str, params: Value) -> Result<Value, DomainError>;

src/application/ports/thumbnail_ports.rs

@@ -5,7 +5,6 @@
 //! image processing implementations.
 
 use crate::common::errors::DomainError;
-use async_trait::async_trait;
 use bytes::Bytes;
 use std::path::{Path, PathBuf};
 use std::sync::Arc;
@@ -63,7 +62,6 @@ pub struct ThumbnailStatsDto {
 /// Implementations handle the actual image processing, caching,
 /// and storage of thumbnails, while the application layer only
 /// interacts through this abstraction.
-#[async_trait]
 pub trait ThumbnailPort: Send + Sync + 'static {
     /// Check if a file is an image that can have thumbnails.
     fn is_supported_image(&self, mime_type: &str) -> bool;

src/application/ports/transcode_ports.rs

@@ -5,7 +5,6 @@
 //! independent of specific image processing implementations.
 
 use crate::common::errors::DomainError;
-use async_trait::async_trait;
 use bytes::Bytes;
 
 /// Supported output formats for image transcoding.
@@ -74,7 +73,6 @@ pub struct TranscodeStatsDto {
 /// Implementations handle the actual image conversion, caching,
 /// and format detection, while the application layer only interacts
 /// through this abstraction.
-#[async_trait]
 pub trait ImageTranscodePort: Send + Sync + 'static {
     /// Check if a MIME type can be transcoded.
     fn can_transcode(&self, mime_type: &str) -> bool;

src/application/ports/trash_ports.rs

@@ -1,10 +1,8 @@
-use async_trait::async_trait;
 
 use crate::application::dtos::trash_dto::TrashedItemDto;
 use crate::common::errors::Result;
 
 /// Port for trash-related use cases
-#[async_trait]
 pub trait TrashUseCase: Send + Sync {
     /// List items in the user's trash
     async fn get_trash_items(&self, user_id: &str) -> Result<Vec<TrashedItemDto>>;

src/application/ports/zip_ports.rs

@@ -5,14 +5,12 @@
 //! implementation details.
 
 use crate::common::errors::DomainError;
-use async_trait::async_trait;
 use tempfile::NamedTempFile;
 
 /// Port for ZIP archive operations.
 ///
 /// Implementations handle the actual ZIP file creation, compression,
 /// and recursive folder traversal.
-#[async_trait]
 pub trait ZipPort: Send + Sync + 'static {
     /// Create a ZIP archive containing the contents of a folder (recursively).
     ///

src/application/services/admin_settings_service.rs

@@ -8,13 +8,14 @@ use crate::common::config::OidcConfig;
 use crate::common::errors::{DomainError, ErrorKind};
 use crate::domain::repositories::settings_repository::SettingsRepository;
 use crate::infrastructure::services::oidc_service::OidcService;
+use crate::infrastructure::repositories::pg::SettingsPgRepository;
 
 /// Admin settings service — manages platform configuration in the database.
 ///
 /// Configuration priority: **env vars > DB settings > defaults**.
 /// Supports hot-reloading OIDC configuration without server restart.
 pub struct AdminSettingsService {
-    settings_repo: Arc<dyn SettingsRepository>,
+    settings_repo: Arc<SettingsPgRepository>,
     env_oidc_config: OidcConfig,
     auth_app_service: Arc<AuthApplicationService>,
     server_base_url: String,
@@ -22,7 +23,7 @@ pub struct AdminSettingsService {
 
 impl AdminSettingsService {
     pub fn new(
-        settings_repo: Arc<dyn SettingsRepository>,
+        settings_repo: Arc<SettingsPgRepository>,
         env_oidc_config: OidcConfig,
         auth_app_service: Arc<AuthApplicationService>,
         server_base_url: String,

src/application/services/app_password_service.rs

@@ -13,6 +13,9 @@ use chrono::{Duration, Utc};
 use moka::future::Cache;
 use std::sync::Arc;
 use std::time::Duration as StdDuration;
+use crate::infrastructure::repositories::pg::AppPasswordPgRepository;
+use crate::infrastructure::services::password_hasher::Argon2PasswordHasher;
+use crate::infrastructure::repositories::pg::UserPgRepository;
 
 /// App password token length (32 random alphanumeric chars after prefix).
 const TOKEN_LENGTH: usize = 32;
@@ -39,9 +42,9 @@ struct CachedBasicAuthResult {
 }
 
 pub struct AppPasswordService {
-    repo: Arc<dyn AppPasswordStoragePort>,
-    hasher: Arc<dyn PasswordHasherPort>,
-    user_repo: Arc<dyn UserStoragePort>,
+    repo: Arc<AppPasswordPgRepository>,
+    hasher: Arc<Argon2PasswordHasher>,
+    user_repo: Arc<UserPgRepository>,
     base_url: String,
 
     /// In-memory cache of successful Basic Auth verifications.
@@ -59,9 +62,9 @@ pub struct AppPasswordService {
 
 impl AppPasswordService {
     pub fn new(
-        repo: Arc<dyn AppPasswordStoragePort>,
-        hasher: Arc<dyn PasswordHasherPort>,
-        user_repo: Arc<dyn UserStoragePort>,
+        repo: Arc<AppPasswordPgRepository>,
+        hasher: Arc<Argon2PasswordHasher>,
+        user_repo: Arc<UserPgRepository>,
         base_url: String,
     ) -> Self {
         let auth_cache = Cache::builder()

src/application/services/auth_application_service.rs

@@ -15,6 +15,12 @@ use std::path::PathBuf;
 use std::sync::Arc;
 use std::sync::RwLock;
 use std::time::Duration;
+use crate::infrastructure::services::password_hasher::Argon2PasswordHasher;
+use crate::application::services::folder_service::FolderService;
+use crate::infrastructure::services::jwt_service::JwtTokenService;
+use crate::infrastructure::services::oidc_service::OidcService;
+use crate::infrastructure::repositories::pg::SessionPgRepository;
+use crate::infrastructure::repositories::pg::UserPgRepository;
 
 /// Tracks a pending OIDC authorization flow (CSRF + PKCE + nonce)
 #[derive(Clone)]
@@ -31,7 +37,7 @@ struct PendingOidcToken {
 
 /// Interior state for OIDC — protected by RwLock for hot-reload.
 struct OidcState {
-    service: Option<Arc<dyn OidcServicePort>>,
+    service: Option<Arc<OidcService>>,
     config: Option<OidcConfig>,
 }
 
@@ -40,11 +46,11 @@ const DEFAULT_ADMIN_QUOTA: i64 = 107_374_182_400;
 const DEFAULT_USER_QUOTA: i64 = 1_073_741_824; // 1 GB
 
 pub struct AuthApplicationService {
-    user_storage: Arc<dyn UserStoragePort>,
-    session_storage: Arc<dyn SessionStoragePort>,
-    password_hasher: Arc<dyn PasswordHasherPort>,
-    token_service: Arc<dyn TokenServicePort>,
-    folder_service: Option<Arc<dyn FolderUseCase>>,
+    user_storage: Arc<UserPgRepository>,
+    session_storage: Arc<SessionPgRepository>,
+    password_hasher: Arc<Argon2PasswordHasher>,
+    token_service: Arc<JwtTokenService>,
+    folder_service: Option<Arc<FolderService>>,
     /// Path to the storage directory, used for disk-space–aware quota calculation
     storage_path: PathBuf,
     oidc: RwLock<OidcState>,
@@ -58,10 +64,10 @@ pub struct AuthApplicationService {
 
 impl AuthApplicationService {
     pub fn new(
-        user_storage: Arc<dyn UserStoragePort>,
-        session_storage: Arc<dyn SessionStoragePort>,
-        password_hasher: Arc<dyn PasswordHasherPort>,
-        token_service: Arc<dyn TokenServicePort>,
+        user_storage: Arc<UserPgRepository>,
+        session_storage: Arc<SessionPgRepository>,
+        password_hasher: Arc<Argon2PasswordHasher>,
+        token_service: Arc<JwtTokenService>,
         storage_path: PathBuf,
     ) -> Self {
         Self {
@@ -133,7 +139,7 @@ impl AuthApplicationService {
     }
 
     /// Configures the folder service, needed to create personal folders
-    pub fn with_folder_service(mut self, folder_service: Arc<dyn FolderUseCase>) -> Self {
+    pub fn with_folder_service(mut self, folder_service: Arc<FolderService>) -> Self {
         self.folder_service = Some(folder_service);
         self
     }
@@ -141,7 +147,7 @@ impl AuthApplicationService {
     /// Configures the OIDC service
     pub fn with_oidc(
         self,
-        oidc_service: Arc<dyn OidcServicePort>,
+        oidc_service: Arc<OidcService>,
         oidc_config: OidcConfig,
     ) -> Self {
         {
@@ -153,7 +159,7 @@ impl AuthApplicationService {
     }
 
     /// Hot-reload OIDC configuration at runtime (called from admin settings service)
-    pub fn reload_oidc(&self, oidc_service: Arc<dyn OidcServicePort>, oidc_config: OidcConfig) {
+    pub fn reload_oidc(&self, oidc_service: Arc<OidcService>, oidc_config: OidcConfig) {
         let mut state = self.oidc.write().unwrap();
         state.service = Some(oidc_service);
         state.config = Some(oidc_config);
@@ -188,7 +194,7 @@ impl AuthApplicationService {
     }
 
     /// Returns an Arc clone of the OIDC service if available
-    pub fn oidc_service(&self) -> Option<Arc<dyn OidcServicePort>> {
+    pub fn oidc_service(&self) -> Option<Arc<OidcService>> {
         let state = self.oidc.read().unwrap();
         state.service.clone()
     }

src/application/services/batch_operations.rs

@@ -17,6 +17,9 @@ use crate::application::ports::trash_ports::TrashUseCase;
 use crate::application::services::folder_service::FolderService;
 use crate::common::config::AppConfig;
 use crate::common::errors::DomainError;
+use crate::application::services::file_management_service::FileManagementService;
+use crate::application::services::file_retrieval_service::FileRetrievalService;
+use crate::application::services::trash_service::TrashService;
 
 /// Specific errors for batch operations
 #[derive(Debug, Error)]
@@ -65,18 +68,18 @@ pub struct BatchStats {
 
 /// Batch operations service
 pub struct BatchOperationService {
-    file_retrieval: Arc<dyn FileRetrievalUseCase>,
-    file_management: Arc<dyn FileManagementUseCase>,
+    file_retrieval: Arc<FileRetrievalService>,
+    file_management: Arc<FileManagementService>,
     folder_service: Arc<FolderService>,
-    trash_service: Option<Arc<dyn TrashUseCase>>,
+    trash_service: Option<Arc<TrashService>>,
     config: AppConfig,
 }
 
 impl BatchOperationService {
     /// Creates a new instance of the batch operations service
     pub fn new(
-        file_retrieval: Arc<dyn FileRetrievalUseCase>,
-        file_management: Arc<dyn FileManagementUseCase>,
+        file_retrieval: Arc<FileRetrievalService>,
+        file_management: Arc<FileManagementService>,
         folder_service: Arc<FolderService>,
         config: AppConfig,
     ) -> Self {
@@ -91,8 +94,8 @@ impl BatchOperationService {
 
     /// Creates a new instance with default configuration
     pub fn default(
-        file_retrieval: Arc<dyn FileRetrievalUseCase>,
-        file_management: Arc<dyn FileManagementUseCase>,
+        file_retrieval: Arc<FileRetrievalService>,
+        file_management: Arc<FileManagementService>,
         folder_service: Arc<FolderService>,
     ) -> Self {
         Self::new(
@@ -104,7 +107,7 @@ impl BatchOperationService {
     }
 
     /// Set the optional trash service (enables batch trash operations)
-    pub fn with_trash_service(mut self, trash_service: Arc<dyn TrashUseCase>) -> Self {
+    pub fn with_trash_service(mut self, trash_service: Arc<TrashService>) -> Self {
         self.trash_service = Some(trash_service);
         self
     }

src/application/services/calendar_service.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use chrono::{DateTime, Utc};
 use std::sync::Arc;
 
@@ -8,18 +7,18 @@ use crate::application::dtos::calendar_dto::{
 };
 use crate::application::ports::calendar_ports::{CalendarStoragePort, CalendarUseCase};
 use crate::common::errors::{DomainError, ErrorKind};
+use crate::infrastructure::adapters::calendar_storage_adapter::CalendarStorageAdapter;
 
 pub struct CalendarService {
-    calendar_storage: Arc<dyn CalendarStoragePort>,
+    calendar_storage: Arc<CalendarStorageAdapter>,
 }
 
 impl CalendarService {
-    pub fn new(calendar_storage: Arc<dyn CalendarStoragePort>) -> Self {
+    pub fn new(calendar_storage: Arc<CalendarStorageAdapter>) -> Self {
         Self { calendar_storage }
     }
 }
 
-#[async_trait]
 impl CalendarUseCase for CalendarService {
     async fn create_calendar(
         &self,

src/application/services/contact_service.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use chrono::Utc;
 use sqlx::types::Uuid;
 use std::sync::Arc;
@@ -17,18 +16,21 @@ use crate::common::errors::DomainError;
 use crate::domain::entities::contact::{Address, AddressBook, Contact, ContactGroup, Email, Phone};
 use crate::domain::repositories::address_book_repository::AddressBookRepository;
 use crate::domain::repositories::contact_repository::{ContactGroupRepository, ContactRepository};
+use crate::infrastructure::repositories::pg::AddressBookPgRepository;
+use crate::infrastructure::repositories::pg::ContactGroupPgRepository;
+use crate::infrastructure::repositories::pg::ContactPgRepository;
 
 pub struct ContactService {
-    address_book_repository: Arc<dyn AddressBookRepository>,
-    contact_repository: Arc<dyn ContactRepository>,
-    contact_group_repository: Arc<dyn ContactGroupRepository>,
+    address_book_repository: Arc<AddressBookPgRepository>,
+    contact_repository: Arc<ContactPgRepository>,
+    contact_group_repository: Arc<ContactGroupPgRepository>,
 }
 
 impl ContactService {
     pub fn new(
-        address_book_repository: Arc<dyn AddressBookRepository>,
-        contact_repository: Arc<dyn ContactRepository>,
-        contact_group_repository: Arc<dyn ContactGroupRepository>,
+        address_book_repository: Arc<AddressBookPgRepository>,
+        contact_repository: Arc<ContactPgRepository>,
+        contact_group_repository: Arc<ContactGroupPgRepository>,
     ) -> Self {
         Self {
             address_book_repository,
@@ -264,7 +266,6 @@ impl ContactService {
     }
 }
 
-#[async_trait]
 impl AddressBookUseCase for ContactService {
     async fn create_address_book(
         &self,
@@ -514,7 +515,6 @@ impl AddressBookUseCase for ContactService {
     }
 }
 
-#[async_trait]
 impl ContactUseCase for ContactService {
     async fn create_contact(&self, dto: CreateContactDto) -> Result<ContactDto, DomainError> {
         let address_book_id = Uuid::parse_str(&dto.address_book_id)
@@ -1092,7 +1092,6 @@ impl ContactUseCase for ContactService {
     }
 }
 
-#[async_trait]
 impl StorageUseCase for ContactService {
     async fn handle_request(
         &self,

src/application/services/device_auth_service.rs

@@ -18,6 +18,10 @@ use crate::application::ports::auth_ports::{
 use crate::common::errors::{DomainError, ErrorKind};
 use crate::domain::entities::device_code::{DeviceCode, DeviceCodeStatus};
 use crate::domain::entities::session::Session;
+use crate::infrastructure::repositories::pg::DeviceCodePgRepository;
+use crate::infrastructure::services::jwt_service::JwtTokenService;
+use crate::infrastructure::repositories::pg::SessionPgRepository;
+use crate::infrastructure::repositories::pg::UserPgRepository;
 
 /// Default device code lifetime: 15 minutes (RFC 8628 recommends 5-30 min).
 const DEVICE_CODE_LIFETIME_SECS: i64 = 900;
@@ -34,20 +38,20 @@ const USER_CODE_LETTER_LEN: usize = 4;
 const USER_CODE_DIGIT_LEN: usize = 4;
 
 pub struct DeviceAuthService {
-    device_code_storage: Arc<dyn DeviceCodeStoragePort>,
-    token_service: Arc<dyn TokenServicePort>,
-    user_storage: Arc<dyn UserStoragePort>,
-    session_storage: Arc<dyn SessionStoragePort>,
+    device_code_storage: Arc<DeviceCodePgRepository>,
+    token_service: Arc<JwtTokenService>,
+    user_storage: Arc<UserPgRepository>,
+    session_storage: Arc<SessionPgRepository>,
     /// Base URL of the server (e.g. "https://cloud.example.com")
     base_url: String,
 }
 
 impl DeviceAuthService {
     pub fn new(
-        device_code_storage: Arc<dyn DeviceCodeStoragePort>,
-        token_service: Arc<dyn TokenServicePort>,
-        user_storage: Arc<dyn UserStoragePort>,
-        session_storage: Arc<dyn SessionStoragePort>,
+        device_code_storage: Arc<DeviceCodePgRepository>,
+        token_service: Arc<JwtTokenService>,
+        user_storage: Arc<UserPgRepository>,
+        session_storage: Arc<SessionPgRepository>,
         base_url: String,
     ) -> Self {
         Self {

src/application/services/favorites_service.rs

@@ -3,26 +3,25 @@ use crate::application::dtos::favorites_dto::{
 };
 use crate::application::ports::favorites_ports::{FavoritesRepositoryPort, FavoritesUseCase};
 use crate::common::errors::{DomainError, ErrorKind, Result};
-use async_trait::async_trait;
 use std::sync::Arc;
 use tracing::info;
+use crate::infrastructure::repositories::pg::FavoritesPgRepository;
 
 /// Implementation of the FavoritesUseCase for managing user favorites.
 ///
 /// Depends on `FavoritesRepositoryPort` (outbound port) instead of
 /// accessing the database directly, following hexagonal architecture.
 pub struct FavoritesService {
-    repo: Arc<dyn FavoritesRepositoryPort>,
+    repo: Arc<FavoritesPgRepository>,
 }
 
 impl FavoritesService {
     /// Create a new FavoritesService with the given repository port
-    pub fn new(repo: Arc<dyn FavoritesRepositoryPort>) -> Self {
+    pub fn new(repo: Arc<FavoritesPgRepository>) -> Self {
         Self { repo }
     }
 }
 
-#[async_trait]
 impl FavoritesUseCase for FavoritesService {
     /// Get all favorites for a user
     async fn get_favorites(&self, user_id: &str) -> Result<Vec<FavoriteItemDto>> {

src/application/services/file_management_service.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use std::sync::Arc;
 
 use crate::application::dtos::file_dto::FileDto;
@@ -7,6 +6,8 @@ use crate::application::ports::storage_ports::{CopyFolderTreeResult, FileWritePo
 use crate::application::ports::trash_ports::TrashUseCase;
 use crate::common::errors::DomainError;
 use tracing::{error, info, warn};
+use crate::infrastructure::repositories::pg::file_blob_write_repository::FileBlobWriteRepository;
+use crate::application::services::trash_service::TrashService;
 
 /// Service for file management operations (move, delete).
 ///
@@ -15,13 +16,13 @@ use tracing::{error, info, warn};
 /// This service only orchestrates trash vs. permanent delete — it never
 /// touches ref_count directly.
 pub struct FileManagementService {
-    file_repository: Arc<dyn FileWritePort>,
-    trash_service: Option<Arc<dyn TrashUseCase>>,
+    file_repository: Arc<FileBlobWriteRepository>,
+    trash_service: Option<Arc<TrashService>>,
 }
 
 impl FileManagementService {
     /// Creates a new FileManagementService.
-    pub fn new(file_repository: Arc<dyn FileWritePort>) -> Self {
+    pub fn new(file_repository: Arc<FileBlobWriteRepository>) -> Self {
         Self {
             file_repository,
             trash_service: None,
@@ -30,8 +31,8 @@ impl FileManagementService {
 
     /// Creates a FileManagementService with a trash service.
     pub fn with_trash(
-        file_repository: Arc<dyn FileWritePort>,
-        trash_service: Option<Arc<dyn TrashUseCase>>,
+        file_repository: Arc<FileBlobWriteRepository>,
+        trash_service: Option<Arc<TrashService>>,
     ) -> Self {
         Self {
             file_repository,
@@ -40,7 +41,6 @@ impl FileManagementService {
     }
 }
 
-#[async_trait]
 impl FileManagementUseCase for FileManagementService {
     async fn move_file(
         &self,

src/application/services/file_retrieval_service.rs

@@ -1,16 +1,16 @@
-use async_trait::async_trait;
 use bytes::{Bytes, BytesMut};
 use futures::{Stream, StreamExt};
 use std::pin::Pin;
 use std::sync::Arc;
 
 use crate::application::dtos::file_dto::FileDto;
-use crate::application::ports::cache_ports::{ContentCachePort, WriteBehindCachePort};
 use crate::application::ports::file_ports::{FileRetrievalUseCase, OptimizedFileContent};
 use crate::application::ports::storage_ports::FileReadPort;
-use crate::application::ports::transcode_ports::{ImageTranscodePort, OutputFormat};
 use crate::common::errors::DomainError;
 use tracing::{debug, info};
+use crate::infrastructure::repositories::pg::file_blob_read_repository::FileBlobReadRepository;
+use crate::infrastructure::services::file_content_cache::FileContentCache;
+use crate::infrastructure::services::image_transcode_service::{ImageTranscodeService, OutputFormat};
 
 /// Threshold below which files are served from RAM cache (10 MB).
 const CACHE_THRESHOLD: u64 = 10 * 1024 * 1024;
@@ -23,48 +23,29 @@ const CACHE_THRESHOLD: u64 = 10 * 1024 * 1024;
 /// - Tier 2: Memory-mapped I/O (10–100 MB)
 /// - Tier 3: Streaming (≥100 MB)
 pub struct FileRetrievalService {
-    file_read: Arc<dyn FileReadPort>,
-    write_behind: Option<Arc<dyn WriteBehindCachePort>>,
-    content_cache: Option<Arc<dyn ContentCachePort>>,
-    transcode: Option<Arc<dyn ImageTranscodePort>>,
+    file_read: Arc<FileBlobReadRepository>,
+    content_cache: Option<Arc<FileContentCache>>,
+    transcode: Option<Arc<ImageTranscodeService>>,
 }
 
 impl FileRetrievalService {
     /// Backward-compatible constructor (simple pass-through).
-    pub fn new(file_repository: Arc<dyn FileReadPort>) -> Self {
+    pub fn new(file_repository: Arc<FileBlobReadRepository>) -> Self {
         Self {
             file_read: file_repository,
-            write_behind: None,
             content_cache: None,
             transcode: None,
         }
     }
 
-    /// Full constructor with all infrastructure ports.
-    pub fn new_full(
-        file_read: Arc<dyn FileReadPort>,
-        write_behind: Arc<dyn WriteBehindCachePort>,
-        content_cache: Arc<dyn ContentCachePort>,
-        transcode: Arc<dyn ImageTranscodePort>,
-    ) -> Self {
-        Self {
-            file_read,
-            write_behind: Some(write_behind),
-            content_cache: Some(content_cache),
-            transcode: Some(transcode),
-        }
-    }
-
     /// Constructor for blob-storage model: read + content cache + transcode.
-    /// No write-behind needed — dedup handled at the repository layer.
     pub fn new_with_cache(
-        file_read: Arc<dyn FileReadPort>,
-        content_cache: Arc<dyn ContentCachePort>,
-        transcode: Arc<dyn ImageTranscodePort>,
+        file_read: Arc<FileBlobReadRepository>,
+        content_cache: Arc<FileContentCache>,
+        transcode: Arc<ImageTranscodeService>,
     ) -> Self {
         Self {
             file_read,
-            write_behind: None,
             content_cache: Some(content_cache),
             transcode: Some(transcode),
         }
@@ -85,7 +66,7 @@ impl FileRetrievalService {
             return None;
         }
         let transcode = self.transcode.as_ref()?;
-        if !transcode.should_transcode(mime, file_size) {
+        if !ImageTranscodeService::should_transcode(mime, file_size) {
             return None;
         }
         let format = OutputFormat::WebP;
@@ -121,37 +102,6 @@ impl FileRetrievalService {
         let modified_at = dto.modified_at;
         let do_transcode = accept_webp && !prefer_original;
 
-        // ── Tier 0: Write-behind cache ───────────────────────
-        if let Some(wb) = &self.write_behind
-            && let Some(pending) = wb.get_pending(id).await
-        {
-            debug!(
-                "⚡ TIER 0 Write-Behind HIT: {} ({} bytes)",
-                file_name,
-                pending.len()
-            );
-            let (data, mime) = if do_transcode {
-                if let Some((t, m)) = self
-                    .try_transcode(id, &pending, &mime_type, file_size, true)
-                    .await
-                {
-                    (t, m)
-                } else {
-                    (pending, mime_type.clone())
-                }
-            } else {
-                (pending, mime_type.clone())
-            };
-            return Ok((
-                dto,
-                OptimizedFileContent::Bytes {
-                    data,
-                    mime_type: mime,
-                    was_transcoded: do_transcode,
-                },
-            ));
-        }
-
         // ── Tier 1: Hot cache + transcode (<10 MB) ──────────
         if file_size < CACHE_THRESHOLD {
             // Check content cache first
@@ -243,7 +193,6 @@ impl FileRetrievalService {
     }
 }
 
-#[async_trait]
 impl FileRetrievalUseCase for FileRetrievalService {
     async fn get_file(&self, id: &str) -> Result<FileDto, DomainError> {
         let file = self.file_read.get_file(id).await?;

src/application/services/file_upload_service.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 
 use std::path::Path;
 use std::sync::Arc;
@@ -8,6 +7,9 @@ use crate::application::ports::file_ports::FileUploadUseCase;
 use crate::application::ports::storage_ports::{FileReadPort, FileWritePort};
 use crate::common::errors::DomainError;
 use tracing::{debug, info, warn};
+use crate::infrastructure::repositories::pg::FileBlobReadRepository;
+use crate::infrastructure::repositories::pg::FileBlobWriteRepository;
+use crate::application::services::storage_usage_service::StorageUsageService;
 
 /// Helper function to extract username from folder path string.
 /// e.g. "My Folder - user1/subfolder/file.txt" → "user1"
@@ -42,17 +44,17 @@ fn extract_username_from_path(path: &str) -> Option<String> {
 /// Peak RAM usage during any upload: ~256 KB (streaming hash) regardless of file size.
 pub struct FileUploadService {
     /// Write port — handles save, streaming, deferred registration
-    file_write: Arc<dyn FileWritePort>,
+    file_write: Arc<FileBlobWriteRepository>,
     /// Read port — needed for WebDAV create_file / update_file
-    file_read: Option<Arc<dyn FileReadPort>>,
+    file_read: Option<Arc<FileBlobReadRepository>>,
     /// Optional storage usage tracking
     storage_usage_service:
-        Option<Arc<dyn crate::application::ports::storage_ports::StorageUsagePort>>,
+        Option<Arc<StorageUsageService>>,
 }
 
 impl FileUploadService {
     /// Constructor with write port only (minimal).
-    pub fn new(file_repository: Arc<dyn FileWritePort>) -> Self {
+    pub fn new(file_repository: Arc<FileBlobWriteRepository>) -> Self {
         Self {
             file_write: file_repository,
             file_read: None,
@@ -62,8 +64,8 @@ impl FileUploadService {
 
     /// Constructor for blob-storage model: write + read ports.
     pub fn new_with_read(
-        file_write: Arc<dyn FileWritePort>,
-        file_read: Arc<dyn FileReadPort>,
+        file_write: Arc<FileBlobWriteRepository>,
+        file_read: Arc<FileBlobReadRepository>,
     ) -> Self {
         Self {
             file_write,
@@ -75,7 +77,7 @@ impl FileUploadService {
     /// Configures the storage usage service
     pub fn with_storage_usage_service(
         mut self,
-        storage_usage_service: Arc<dyn crate::application::ports::storage_ports::StorageUsagePort>,
+        storage_usage_service: Arc<StorageUsageService>,
     ) -> Self {
         self.storage_usage_service = Some(storage_usage_service);
         self
@@ -106,7 +108,6 @@ impl FileUploadService {
     }
 }
 
-#[async_trait]
 impl FileUploadUseCase for FileUploadService {
     /// Streaming upload from a temp file on disk.
     ///

src/application/services/file_use_case_factory.rs

@@ -1,24 +1,23 @@
 use std::sync::Arc;
 
-use crate::application::ports::file_ports::{
-    FileManagementUseCase, FileRetrievalUseCase, FileUploadUseCase, FileUseCaseFactory,
-};
-use crate::application::ports::storage_ports::{FileReadPort, FileWritePort};
+use crate::application::ports::file_ports::FileUseCaseFactory;
 use crate::application::services::file_management_service::FileManagementService;
 use crate::application::services::file_retrieval_service::FileRetrievalService;
 use crate::application::services::file_upload_service::FileUploadService;
+use crate::infrastructure::repositories::pg::file_blob_read_repository::FileBlobReadRepository;
+use crate::infrastructure::repositories::pg::file_blob_write_repository::FileBlobWriteRepository;
 
 /// Factory for creating file use case implementations
 pub struct AppFileUseCaseFactory {
-    file_read_repository: Arc<dyn FileReadPort>,
-    file_write_repository: Arc<dyn FileWritePort>,
+    file_read_repository: Arc<FileBlobReadRepository>,
+    file_write_repository: Arc<FileBlobWriteRepository>,
 }
 
 impl AppFileUseCaseFactory {
     /// Creates a new factory for file use cases
     pub fn new(
-        file_read_repository: Arc<dyn FileReadPort>,
-        file_write_repository: Arc<dyn FileWritePort>,
+        file_read_repository: Arc<FileBlobReadRepository>,
+        file_write_repository: Arc<FileBlobWriteRepository>,
     ) -> Self {
         Self {
             file_read_repository,
@@ -28,15 +27,15 @@ impl AppFileUseCaseFactory {
 }
 
 impl FileUseCaseFactory for AppFileUseCaseFactory {
-    fn create_file_upload_use_case(&self) -> Arc<dyn FileUploadUseCase> {
+    fn create_file_upload_use_case(&self) -> Arc<FileUploadService> {
         Arc::new(FileUploadService::new(self.file_write_repository.clone()))
     }
 
-    fn create_file_retrieval_use_case(&self) -> Arc<dyn FileRetrievalUseCase> {
+    fn create_file_retrieval_use_case(&self) -> Arc<FileRetrievalService> {
         Arc::new(FileRetrievalService::new(self.file_read_repository.clone()))
     }
 
-    fn create_file_management_use_case(&self) -> Arc<dyn FileManagementUseCase> {
+    fn create_file_management_use_case(&self) -> Arc<FileManagementService> {
         Arc::new(FileManagementService::new(
             self.file_write_repository.clone(),
         ))

src/application/services/folder_service.rs

@@ -2,20 +2,20 @@ use crate::application::dtos::folder_dto::{
     CreateFolderDto, FolderDto, MoveFolderDto, RenameFolderDto,
 };
 use crate::application::ports::inbound::FolderUseCase;
-use crate::application::ports::outbound::FolderStoragePort;
 use crate::common::errors::{DomainError, ErrorKind};
 use crate::domain::services::path_service::StoragePath;
-use async_trait::async_trait;
 use std::sync::Arc;
+use crate::infrastructure::repositories::pg::folder_db_repository::FolderDbRepository;
+use crate::domain::repositories::folder_repository::FolderRepository;
 
 /// Implementation of the use case for folder operations
 pub struct FolderService {
-    folder_storage: Arc<dyn FolderStoragePort>,
+    folder_storage: Arc<FolderDbRepository>,
 }
 
 impl FolderService {
     /// Creates a new folder service
-    pub fn new(folder_storage: Arc<dyn FolderStoragePort>) -> Self {
+    pub fn new(folder_storage: Arc<FolderDbRepository>) -> Self {
         Self { folder_storage }
     }
 
@@ -23,7 +23,6 @@ impl FolderService {
     pub fn new_stub() -> impl FolderUseCase {
         struct FolderServiceStub;
 
-        #[async_trait]
         impl FolderUseCase for FolderServiceStub {
             async fn create_folder(&self, _dto: CreateFolderDto) -> Result<FolderDto, DomainError> {
                 Ok(FolderDto::empty())
@@ -124,7 +123,6 @@ impl FolderService {
     }
 }
 
-#[async_trait]
 impl FolderUseCase for FolderService {
     /// Creates a new folder
     async fn create_folder(&self, dto: CreateFolderDto) -> Result<FolderDto, DomainError> {

src/application/services/i18n_application_service.rs

@@ -1,43 +1,23 @@
 use std::sync::Arc;
 
 use crate::domain::services::i18n_service::{I18nResult, I18nService, Locale};
+use crate::infrastructure::services::file_system_i18n_service::FileSystemI18nService;
 
 /// Service for i18n operations
 pub struct I18nApplicationService {
-    i18n_service: Arc<dyn I18nService>,
+    i18n_service: Arc<FileSystemI18nService>,
 }
 
 impl I18nApplicationService {
     /// Creates a dummy service for testing
     pub fn dummy() -> Self {
-        struct DummyI18nService;
-
-        #[async_trait::async_trait]
-        impl I18nService for DummyI18nService {
-            async fn translate(&self, _key: &str, _locale: Locale) -> I18nResult<String> {
-                Ok("DUMMY_TRANSLATION".to_string())
-            }
-
-            async fn load_translations(&self, _locale: Locale) -> I18nResult<()> {
-                Ok(())
-            }
-
-            async fn available_locales(&self) -> Vec<Locale> {
-                vec![Locale::English, Locale::Spanish]
-            }
-
-            async fn is_supported(&self, _locale: Locale) -> bool {
-                true
-            }
-        }
-
         Self {
-            i18n_service: Arc::new(DummyI18nService),
+            i18n_service: Arc::new(FileSystemI18nService::dummy()),
         }
     }
 
     /// Creates a new i18n application service
-    pub fn new(i18n_service: Arc<dyn I18nService>) -> Self {
+    pub fn new(i18n_service: Arc<FileSystemI18nService>) -> Self {
         Self { i18n_service }
     }
 

src/application/services/recent_service.rs

@@ -1,22 +1,22 @@
 use crate::application::dtos::recent_dto::RecentItemDto;
 use crate::application::ports::recent_ports::{RecentItemsRepositoryPort, RecentItemsUseCase};
 use crate::common::errors::{DomainError, ErrorKind, Result};
-use async_trait::async_trait;
 use std::sync::Arc;
 use tracing::info;
+use crate::infrastructure::repositories::pg::RecentItemsPgRepository;
 
 /// Implementation of the use case for managing recent items.
 ///
 /// Depends on `RecentItemsRepositoryPort` (outbound port) instead
 /// of accessing `PgPool` directly, following the hexagonal architecture.
 pub struct RecentService {
-    repo: Arc<dyn RecentItemsRepositoryPort>,
+    repo: Arc<RecentItemsPgRepository>,
     max_recent_items: i32,
 }
 
 impl RecentService {
     /// Create a new recent items service
-    pub fn new(repo: Arc<dyn RecentItemsRepositoryPort>, max_recent_items: i32) -> Self {
+    pub fn new(repo: Arc<RecentItemsPgRepository>, max_recent_items: i32) -> Self {
         Self {
             repo,
             max_recent_items: max_recent_items.clamp(1, 100),
@@ -24,7 +24,6 @@ impl RecentService {
     }
 }
 
-#[async_trait]
 impl RecentItemsUseCase for RecentService {
     /// Get recent items for a user
     async fn get_recent_items(

src/application/services/search_service.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use std::cmp::Reverse;
 use std::sync::Arc;
 use std::time::{Duration, Instant};
@@ -13,11 +12,13 @@ use crate::application::dtos::search_dto::{
     SearchSuggestionItem, SearchSuggestionsDto,
 };
 use crate::application::ports::inbound::SearchUseCase;
-use crate::application::ports::outbound::FolderStoragePort;
 use crate::application::ports::storage_ports::FileReadPort;
 use crate::common::errors::Result;
 use crate::domain::entities::folder::Folder;
 use std::hash::{Hash, Hasher};
+use crate::infrastructure::repositories::pg::file_blob_read_repository::FileBlobReadRepository;
+use crate::infrastructure::repositories::pg::folder_db_repository::FolderDbRepository;
+use crate::domain::repositories::folder_repository::FolderRepository;
 
 /**
  * High-performance search service implementation for files and folders.
@@ -37,10 +38,10 @@ use std::hash::{Hash, Hasher};
  */
 pub struct SearchService {
     /// Repository for file operations
-    file_repository: Arc<dyn FileReadPort>,
+    file_repository: Arc<FileBlobReadRepository>,
 
     /// Repository for folder operations
-    folder_repository: Arc<dyn FolderStoragePort>,
+    folder_repository: Arc<FolderDbRepository>,
 
     /// Lock-free concurrent cache with automatic TTL and LRU eviction (moka).
     /// Values are `Arc<SearchResultsDto>` so cache insert/hit is a single
@@ -109,8 +110,8 @@ impl SearchService {
      * Creates a new instance of the search service.
      */
     pub fn new(
-        file_repository: Arc<dyn FileReadPort>,
-        folder_repository: Arc<dyn FolderStoragePort>,
+        file_repository: Arc<FileBlobReadRepository>,
+        folder_repository: Arc<FolderDbRepository>,
         cache_ttl: u64,
         max_cache_size: usize,
     ) -> Self {
@@ -255,7 +256,6 @@ impl SearchService {
 
 // ─── SearchUseCase trait implementation ──────────────────────────────────
 
-#[async_trait]
 impl SearchUseCase for SearchService {
     /**
      * Performs a search based on the specified criteria.
@@ -489,7 +489,6 @@ impl SearchService {
     pub fn new_stub() -> impl SearchUseCase {
         struct SearchServiceStub;
 
-        #[async_trait]
         impl SearchUseCase for SearchServiceStub {
             async fn search(
                 &self,

src/application/services/share_service.rs

@@ -1,6 +1,5 @@
 use std::sync::Arc;
 
-use async_trait::async_trait;
 use thiserror::Error;
 use tokio::sync::Semaphore;
 
@@ -12,7 +11,6 @@ use crate::{
         },
         ports::{
             auth_ports::PasswordHasherPort,
-            outbound::FolderStoragePort,
             share_ports::{ShareStoragePort, ShareUseCase},
             storage_ports::FileReadPort,
         },
@@ -20,6 +18,11 @@ use crate::{
     common::{config::AppConfig, errors::DomainError},
     domain::entities::share::{Share, ShareItemType, SharePermissions},
 };
+use crate::infrastructure::services::password_hasher::Argon2PasswordHasher;
+use crate::infrastructure::repositories::pg::file_blob_read_repository::FileBlobReadRepository;
+use crate::infrastructure::repositories::pg::folder_db_repository::FolderDbRepository;
+use crate::infrastructure::repositories::pg::SharePgRepository;
+use crate::domain::repositories::folder_repository::FolderRepository;
 
 #[derive(Debug, Error)]
 pub enum ShareServiceError {
@@ -67,10 +70,10 @@ const MAX_CONCURRENT_HASHES: usize = 2;
 
 pub struct ShareService {
     config: Arc<AppConfig>,
-    share_repository: Arc<dyn ShareStoragePort>,
-    file_repository: Arc<dyn FileReadPort>,
-    folder_repository: Arc<dyn FolderStoragePort>,
-    password_hasher: Arc<dyn PasswordHasherPort>,
+    share_repository: Arc<SharePgRepository>,
+    file_repository: Arc<FileBlobReadRepository>,
+    folder_repository: Arc<FolderDbRepository>,
+    password_hasher: Arc<Argon2PasswordHasher>,
     /// Bounds the number of in-flight Argon2 password hashes to avoid
     /// saturating the blocking thread pool and consuming excessive RAM.
     hash_semaphore: Arc<Semaphore>,
@@ -79,10 +82,10 @@ pub struct ShareService {
 impl ShareService {
     pub fn new(
         config: Arc<AppConfig>,
-        share_repository: Arc<dyn ShareStoragePort>,
-        file_repository: Arc<dyn FileReadPort>,
-        folder_repository: Arc<dyn FolderStoragePort>,
-        password_hasher: Arc<dyn PasswordHasherPort>,
+        share_repository: Arc<SharePgRepository>,
+        file_repository: Arc<FileBlobReadRepository>,
+        folder_repository: Arc<FolderDbRepository>,
+        password_hasher: Arc<Argon2PasswordHasher>,
     ) -> Self {
         Self {
             config,
@@ -139,7 +142,6 @@ impl ShareService {
     }
 }
 
-#[async_trait]
 impl ShareUseCase for ShareService {
     async fn create_shared_link(
         &self,
@@ -400,13 +402,11 @@ mod tests {
     use crate::application::ports::share_ports::ShareStoragePort;
     use crate::common::config::AppConfig;
     use crate::domain::repositories::folder_repository::FolderRepository;
-    use async_trait::async_trait;
     use std::collections::HashMap;
     use std::sync::Mutex;
 
     struct MockPasswordHasher;
 
-    #[async_trait]
     impl PasswordHasherPort for MockPasswordHasher {
         async fn hash_password(&self, password: &str) -> Result<String, DomainError> {
             Ok(format!("hashed_{}", password))
@@ -420,7 +420,6 @@ mod tests {
     struct MockFileRepository;
     struct MockFolderRepository;
 
-    #[async_trait]
     impl FileReadPort for MockFileRepository {
         async fn get_file(
             &self,
@@ -523,7 +522,6 @@ mod tests {
         }
     }
 
-    #[async_trait]
     impl FolderRepository for MockFolderRepository {
         async fn create_folder(
             &self,
@@ -671,7 +669,6 @@ mod tests {
         }
     }
 
-    #[async_trait]
     impl ShareStoragePort for MockShareRepository {
         async fn save_share(&self, share: &Share) -> Result<Share, DomainError> {
             let mut shares = self.shares.lock().unwrap();

src/application/services/storage_usage_service.rs

@@ -1,11 +1,11 @@
 use crate::application::ports::auth_ports::UserStoragePort;
 use crate::application::ports::storage_ports::StorageUsagePort;
 use crate::common::errors::DomainError;
-use async_trait::async_trait;
 use sqlx::PgPool;
 use std::sync::Arc;
 use tokio::task;
 use tracing::{debug, error, info};
+use crate::infrastructure::repositories::pg::UserPgRepository;
 
 /**
  * Service for managing and updating user storage usage statistics.
@@ -18,12 +18,12 @@ use tracing::{debug, error, info};
  */
 pub struct StorageUsageService {
     pool: Arc<PgPool>,
-    user_repository: Arc<dyn UserStoragePort>,
+    user_repository: Arc<UserPgRepository>,
 }
 
 impl StorageUsageService {
     /// Creates a new storage usage service
-    pub fn new(pool: Arc<PgPool>, user_repository: Arc<dyn UserStoragePort>) -> Self {
+    pub fn new(pool: Arc<PgPool>, user_repository: Arc<UserPgRepository>) -> Self {
         Self {
             pool,
             user_repository,
@@ -111,7 +111,6 @@ impl StorageUsageService {
  * Implementation of the StorageUsagePort trait to expose storage usage services
  * to the application layer.
  */
-#[async_trait]
 impl StorageUsagePort for StorageUsageService {
     async fn update_user_storage_usage(&self, user_id: &str) -> Result<i64, DomainError> {
         StorageUsageService::update_user_storage_usage(self, user_id).await

src/application/services/trash_service.rs

@@ -1,15 +1,18 @@
-use async_trait::async_trait;
 use std::sync::Arc;
 use tracing::{debug, error, info, instrument};
 use uuid::Uuid;
 
 use crate::application::dtos::trash_dto::TrashedItemDto;
-use crate::application::ports::outbound::FolderStoragePort;
 use crate::application::ports::storage_ports::{FileReadPort, FileWritePort};
 use crate::application::ports::trash_ports::TrashUseCase;
 use crate::common::errors::{DomainError, ErrorKind, Result};
 use crate::domain::entities::trashed_item::{TrashedItem, TrashedItemType};
 use crate::domain::repositories::trash_repository::TrashRepository;
+use crate::infrastructure::repositories::pg::file_blob_read_repository::FileBlobReadRepository;
+use crate::infrastructure::repositories::pg::file_blob_write_repository::FileBlobWriteRepository;
+use crate::infrastructure::repositories::pg::folder_db_repository::FolderDbRepository;
+use crate::infrastructure::repositories::pg::trash_db_repository::TrashDbRepository;
+use crate::domain::repositories::folder_repository::FolderRepository;
 
 /**
  * Application service for trash operations.
@@ -26,16 +29,16 @@ use crate::domain::repositories::trash_repository::TrashRepository;
  */
 pub struct TrashService {
     /// Repository for trash-specific operations like listing and retrieving trashed items
-    trash_repository: Arc<dyn TrashRepository>,
+    trash_repository: Arc<TrashDbRepository>,
 
     /// Port for file read operations (get file metadata)
-    file_read_port: Arc<dyn FileReadPort>,
+    file_read_port: Arc<FileBlobReadRepository>,
 
     /// Port for file write operations (trash, restore, delete)
-    file_write_port: Arc<dyn FileWritePort>,
+    file_write_port: Arc<FileBlobWriteRepository>,
 
     /// Port for folder operations (get folder, trash, restore, delete)
-    folder_storage_port: Arc<dyn FolderStoragePort>,
+    folder_storage_port: Arc<FolderDbRepository>,
 
     /// Number of days items should be kept in trash before automatic cleanup
     retention_days: u32,
@@ -43,10 +46,10 @@ pub struct TrashService {
 
 impl TrashService {
     pub fn new(
-        trash_repository: Arc<dyn TrashRepository>,
-        file_read_port: Arc<dyn FileReadPort>,
-        file_write_port: Arc<dyn FileWritePort>,
-        folder_storage_port: Arc<dyn FolderStoragePort>,
+        trash_repository: Arc<TrashDbRepository>,
+        file_read_port: Arc<FileBlobReadRepository>,
+        file_write_port: Arc<FileBlobWriteRepository>,
+        folder_storage_port: Arc<FolderDbRepository>,
         retention_days: u32,
     ) -> Self {
         Self {
@@ -118,7 +121,6 @@ impl TrashService {
     }
 }
 
-#[async_trait]
 impl TrashUseCase for TrashService {
     #[instrument(skip(self))]
     async fn get_trash_items(&self, user_id: &str) -> Result<Vec<TrashedItemDto>> {

src/application/services/trash_service_test.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use bytes::Bytes;
 use chrono::Utc;
 use futures::Stream;
@@ -40,7 +39,6 @@ impl MockTrashRepository {
     }
 }
 
-#[async_trait]
 impl TrashRepository for MockTrashRepository {
     async fn add_to_trash(&self, item: &TrashedItem) -> Result<()> {
         let mut items = self.trash_items.lock().unwrap();
@@ -135,7 +133,6 @@ impl MockFileRepository {
     }
 }
 
-#[async_trait]
 impl FileReadPort for MockFileRepository {
     async fn get_file(&self, id: &str) -> std::result::Result<File, DomainError> {
         let files = self.files.lock().unwrap();
@@ -216,7 +213,6 @@ impl FileReadPort for MockFileRepository {
     }
 }
 
-#[async_trait]
 impl FileWritePort for MockFileRepository {
     async fn save_file_from_temp(
         &self,
@@ -350,7 +346,6 @@ impl MockFolderRepository {
     }
 }
 
-#[async_trait]
 impl FolderRepository for MockFolderRepository {
     async fn create_folder(
         &self,
@@ -514,8 +509,8 @@ mod tests {
 
         let service = TrashService::new(
             trash_repo.clone(),
-            file_repo.clone() as Arc<dyn FileReadPort>,
-            file_repo.clone() as Arc<dyn FileWritePort>,
+            file_repo.clone() as Arc<FileBlobReadRepository>,
+            file_repo.clone() as Arc<FileBlobWriteRepository>,
             folder_repo.clone(),
             30, // 30 days retention
         );
@@ -588,8 +583,8 @@ mod tests {
 
         let service = TrashService::new(
             trash_repo.clone(),
-            file_repo.clone() as Arc<dyn FileReadPort>,
-            file_repo.clone() as Arc<dyn FileWritePort>,
+            file_repo.clone() as Arc<FileBlobReadRepository>,
+            file_repo.clone() as Arc<FileBlobWriteRepository>,
             folder_repo.clone(),
             30, // 30 days retention
         );
@@ -653,8 +648,8 @@ mod tests {
 
         let service = TrashService::new(
             trash_repo.clone(),
-            file_repo.clone() as Arc<dyn FileReadPort>,
-            file_repo.clone() as Arc<dyn FileWritePort>,
+            file_repo.clone() as Arc<FileBlobReadRepository>,
+            file_repo.clone() as Arc<FileBlobWriteRepository>,
             folder_repo.clone(),
             30, // 30 days retention
         );
@@ -723,8 +718,8 @@ mod tests {
 
         let service = TrashService::new(
             trash_repo.clone(),
-            file_repo.clone() as Arc<dyn FileReadPort>,
-            file_repo.clone() as Arc<dyn FileWritePort>,
+            file_repo.clone() as Arc<FileBlobReadRepository>,
+            file_repo.clone() as Arc<FileBlobWriteRepository>,
             folder_repo.clone(),
             30, // 30 days retention
         );
@@ -792,8 +787,8 @@ mod tests {
 
         let service = TrashService::new(
             trash_repo.clone(),
-            file_repo.clone() as Arc<dyn FileReadPort>,
-            file_repo.clone() as Arc<dyn FileWritePort>,
+            file_repo.clone() as Arc<FileBlobReadRepository>,
+            file_repo.clone() as Arc<FileBlobWriteRepository>,
             folder_repo.clone(),
             30, // 30 days retention
         );

src/common/di.rs

@@ -7,22 +7,7 @@ use crate::infrastructure::db::DbPools;
 use crate::application::services::admin_settings_service::AdminSettingsService;
 use crate::application::services::auth_application_service::AuthApplicationService;
 
-use crate::application::ports::cache_ports::ContentCachePort;
-use crate::application::ports::chunked_upload_ports::ChunkedUploadPort;
-
-use crate::application::ports::dedup_ports::DedupPort;
-use crate::application::ports::favorites_ports::FavoritesUseCase;
-use crate::application::ports::file_ports::{
-    FileManagementUseCase, FileRetrievalUseCase, FileUploadUseCase, FileUseCaseFactory,
-};
-use crate::application::ports::inbound::{FolderUseCase, SearchUseCase};
-use crate::application::ports::outbound::FolderStoragePort;
-use crate::application::ports::recent_ports::RecentItemsUseCase;
-use crate::application::ports::storage_ports::{FileReadPort, FileWritePort};
-use crate::application::ports::thumbnail_ports::ThumbnailPort;
-use crate::application::ports::transcode_ports::ImageTranscodePort;
-use crate::application::ports::trash_ports::TrashUseCase;
-use crate::application::ports::zip_ports::ZipPort;
+use crate::application::ports::file_ports::FileUseCaseFactory;
 use crate::application::services::favorites_service::FavoritesService;
 use crate::application::services::folder_service::FolderService;
 use crate::application::services::i18n_application_service::I18nApplicationService;
@@ -35,7 +20,6 @@ use crate::application::services::{
 };
 use crate::common::config::AppConfig;
 use crate::common::errors::DomainError;
-use crate::domain::services::i18n_service::I18nService;
 use crate::infrastructure::repositories::pg::SharePgRepository;
 use crate::infrastructure::repositories::pg::{
     FileBlobReadRepository, FileBlobWriteRepository, FolderDbRepository, TrashDbRepository,
@@ -47,7 +31,29 @@ use crate::infrastructure::services::file_system_i18n_service::FileSystemI18nSer
 use crate::infrastructure::services::path_service::PathService;
 use crate::infrastructure::services::trash_cleanup_service::TrashCleanupService;
 
-use crate::common::stubs::StubZipPort;
+
+use crate::application::services::device_auth_service::DeviceAuthService;
+use crate::application::services::app_password_service::AppPasswordService;
+use crate::application::services::calendar_service::CalendarService;
+use crate::application::services::storage_usage_service::StorageUsageService;
+use crate::infrastructure::adapters::contact_storage_adapter::ContactStorageAdapter;
+use crate::infrastructure::repositories::DeviceCodePgRepository;
+use crate::infrastructure::repositories::AppPasswordPgRepository;
+use crate::infrastructure::repositories::pg::{
+    AddressBookPgRepository, CalendarEventPgRepository, CalendarPgRepository,
+    ContactGroupPgRepository, ContactPgRepository, SessionPgRepository, UserPgRepository,
+};
+use crate::infrastructure::services::password_hasher::Argon2PasswordHasher;
+use crate::infrastructure::services::jwt_service::JwtTokenService;
+use crate::infrastructure::services::path_resolver_service::PathResolverService;
+use crate::application::services::wopi_lock_service::WopiLockService;
+use crate::application::services::wopi_token_service::WopiTokenService;
+use crate::infrastructure::services::wopi_discovery_service::WopiDiscoveryService;
+use crate::infrastructure::services::chunked_upload_service::ChunkedUploadService;
+use crate::infrastructure::services::dedup_service::DedupService;
+use crate::infrastructure::services::image_transcode_service::ImageTranscodeService;
+use crate::infrastructure::services::thumbnail_service::ThumbnailService;
+use crate::infrastructure::services::zip_service::ZipService;
 
 /// Factory for the different application components
 ///
@@ -161,7 +167,7 @@ impl AppServiceFactory {
             chunked_upload_service,
             image_transcode_service,
             dedup_service,
-            zip_service: Arc::new(StubZipPort), // Placeholder - replaced after app services init
+            zip_service: None, // Placeholder - replaced after app services init
             config: self.config.clone(),
         })
     }
@@ -176,16 +182,16 @@ impl AppServiceFactory {
     ) -> RepositoryServices {
         // Folder repository — PostgreSQL-backed virtual folders
         let folder_repo_concrete = Arc::new(FolderDbRepository::new(db_pool.clone()));
-        let folder_repository: Arc<dyn FolderStoragePort> = folder_repo_concrete.clone();
+        let folder_repository: Arc<FolderDbRepository> = folder_repo_concrete.clone();
 
         // File repositories — PostgreSQL metadata + blob content via DedupService
-        let file_read_repository: Arc<dyn FileReadPort> = Arc::new(FileBlobReadRepository::new(
+        let file_read_repository: Arc<FileBlobReadRepository> = Arc::new(FileBlobReadRepository::new(
             db_pool.clone(),
             core.dedup_service.clone(),
             folder_repo_concrete.clone(),
         ));
 
-        let file_write_repository: Arc<dyn FileWritePort> = Arc::new(FileBlobWriteRepository::new(
+        let file_write_repository: Arc<FileBlobWriteRepository> = Arc::new(FileBlobWriteRepository::new(
             db_pool.clone(),
             core.dedup_service.clone(),
             folder_repo_concrete.clone(),
@@ -201,7 +207,7 @@ impl AppServiceFactory {
                 core.config.storage.trash_retention_days,
             ))
                 as Arc<
-                    dyn crate::domain::repositories::trash_repository::TrashRepository,
+                    TrashDbRepository,
                 >)
         } else {
             None
@@ -226,7 +232,7 @@ impl AppServiceFactory {
         &self,
         core: &CoreServices,
         repos: &RepositoryServices,
-        trash_service: Option<Arc<dyn TrashUseCase>>,
+        trash_service: Option<Arc<TrashService>>,
     ) -> ApplicationServices {
         // Main services
         let folder_service = Arc::new(FolderService::new(repos.folder_repository.clone()));
@@ -258,7 +264,7 @@ impl AppServiceFactory {
         let i18n_service = Arc::new(I18nApplicationService::new(repos.i18n_repository.clone()));
 
         // Search service with cache
-        let search_service: Option<Arc<dyn SearchUseCase>> = Some(Arc::new(SearchService::new(
+        let search_service: Option<Arc<SearchService>> = Some(Arc::new(SearchService::new(
             repos.file_read_repository.clone(),
             repos.folder_repository.clone(),
             300,  // Cache TTL in seconds (5 minutes)
@@ -289,7 +295,7 @@ impl AppServiceFactory {
     pub async fn create_trash_service(
         &self,
         repos: &RepositoryServices,
-    ) -> Option<Arc<dyn TrashUseCase>> {
+    ) -> Option<Arc<TrashService>> {
         if !self.config.features.enable_trash {
             tracing::info!("Trash service is disabled in configuration");
             return None;
@@ -315,7 +321,7 @@ impl AppServiceFactory {
         cleanup_service.start_cleanup_job().await;
         tracing::info!("Trash service initialized with daily cleanup schedule");
 
-        Some(service as Arc<dyn TrashUseCase>)
+        Some(service as Arc<TrashService>)
     }
 
     /// Creates the sharing service
@@ -323,7 +329,7 @@ impl AppServiceFactory {
         &self,
         repos: &RepositoryServices,
         db_pool: &Arc<PgPool>,
-    ) -> Option<Arc<dyn crate::application::ports::share_ports::ShareUseCase>> {
+    ) -> Option<Arc<ShareService>> {
         if !self.config.features.enable_file_sharing {
             tracing::info!("File sharing service is disabled in configuration");
             return None;
@@ -332,7 +338,7 @@ impl AppServiceFactory {
         let share_repository = Arc::new(SharePgRepository::new(db_pool.clone()));
 
         // Build a password hasher for share password verification
-        let password_hasher: Arc<dyn crate::application::ports::auth_ports::PasswordHasherPort> =
+        let password_hasher: Arc<Argon2PasswordHasher> =
             Arc::new(
                 crate::infrastructure::services::password_hasher::Argon2PasswordHasher::new(
                     self.config.auth.hash_memory_cost,
@@ -354,7 +360,7 @@ impl AppServiceFactory {
     }
 
     /// Creates the favorites service (requires database)
-    pub fn create_favorites_service(&self, db_pool: &Arc<PgPool>) -> Arc<dyn FavoritesUseCase> {
+    pub fn create_favorites_service(&self, db_pool: &Arc<PgPool>) -> Arc<FavoritesService> {
         let repo = Arc::new(
             crate::infrastructure::repositories::pg::FavoritesPgRepository::new(db_pool.clone()),
         );
@@ -364,7 +370,7 @@ impl AppServiceFactory {
     }
 
     /// Creates the recent items service (requires database)
-    pub fn create_recent_service(&self, db_pool: &Arc<PgPool>) -> Arc<dyn RecentItemsUseCase> {
+    pub fn create_recent_service(&self, db_pool: &Arc<PgPool>) -> Arc<RecentService> {
         let repo = Arc::new(
             crate::infrastructure::repositories::pg::RecentItemsPgRepository::new(db_pool.clone()),
         );
@@ -406,7 +412,7 @@ impl AppServiceFactory {
         _repos: &RepositoryServices,
         db_pool: &Arc<PgPool>,
         maintenance_pool: &Arc<PgPool>,
-    ) -> Arc<dyn crate::application::ports::storage_ports::StorageUsagePort> {
+    ) -> Arc<StorageUsageService> {
         let user_repository = Arc::new(
             crate::infrastructure::repositories::pg::UserPgRepository::new(db_pool.clone()),
         );
@@ -455,10 +461,10 @@ impl AppServiceFactory {
         apps.share_service = share_service.clone();
 
         // 6. Database-dependent services (PgPool always available in blob model)
-        let favorites_service: Option<Arc<dyn FavoritesUseCase>>;
-        let recent_service: Option<Arc<dyn RecentItemsUseCase>>;
+        let favorites_service: Option<Arc<FavoritesService>>;
+        let recent_service: Option<Arc<RecentService>>;
         let storage_usage_service: Option<
-            Arc<dyn crate::application::ports::storage_ports::StorageUsagePort>,
+            Arc<StorageUsageService>,
         >;
         let mut auth_services: Option<crate::common::di::AuthServices> = None;
 
@@ -509,14 +515,14 @@ impl AppServiceFactory {
         self.preload_translations(&apps.i18n_service).await;
 
         // 8. Build the ZipService with real application services
-        let zip_service: Arc<dyn crate::application::ports::zip_ports::ZipPort> = Arc::new(
+        let zip_service: Arc<ZipService> = Arc::new(
             crate::infrastructure::services::zip_service::ZipService::new(
                 apps.file_retrieval_service.clone(),
                 apps.folder_service.clone(),
             ),
         );
         let mut core = core;
-        core.zip_service = zip_service;
+        core.zip_service = Some(zip_service);
 
         // 9. Assemble final AppState
         let mut app_state = AppState {
@@ -596,16 +602,14 @@ impl AppServiceFactory {
 
             // 9c. Wire Device Authorization Grant (RFC 8628) service
             {
-                use crate::application::services::device_auth_service::DeviceAuthService;
-                use crate::infrastructure::repositories::DeviceCodePgRepository;
 
                 let device_code_repo = Arc::new(DeviceCodePgRepository::new(pool.clone()));
-                let user_repo: Arc<dyn crate::application::ports::auth_ports::UserStoragePort> =
+                let user_repo: Arc<UserPgRepository> =
                     Arc::new(crate::infrastructure::repositories::UserPgRepository::new(
                         pool.clone(),
                     ));
                 let session_repo: Arc<
-                    dyn crate::application::ports::auth_ports::SessionStoragePort,
+                    SessionPgRepository,
                 > = Arc::new(
                     crate::infrastructure::repositories::SessionPgRepository::new(pool.clone()),
                 );
@@ -624,13 +628,11 @@ impl AppServiceFactory {
 
             // 9d. Wire App Password service
             {
-                use crate::application::services::app_password_service::AppPasswordService;
-                use crate::infrastructure::repositories::AppPasswordPgRepository;
 
                 let app_pw_repo: Arc<
-                    dyn crate::application::ports::auth_ports::AppPasswordStoragePort,
+                    AppPasswordPgRepository,
                 > = Arc::new(AppPasswordPgRepository::new(pool.clone()));
-                let hasher: Arc<dyn crate::application::ports::auth_ports::PasswordHasherPort> =
+                let hasher: Arc<Argon2PasswordHasher> =
                     Arc::new(
                         crate::infrastructure::services::password_hasher::Argon2PasswordHasher::new(
                             self.config.auth.hash_memory_cost,
@@ -638,7 +640,7 @@ impl AppServiceFactory {
                             self.config.auth.hash_parallelism,
                         ),
                     );
-                let user_repo: Arc<dyn crate::application::ports::auth_ports::UserStoragePort> =
+                let user_repo: Arc<UserPgRepository> =
                     Arc::new(crate::infrastructure::repositories::UserPgRepository::new(
                         pool.clone(),
                     ));
@@ -657,7 +659,6 @@ impl AppServiceFactory {
 
         // 9e. Wire PathResolver for single-query WebDAV path resolution
         {
-            use crate::infrastructure::services::path_resolver_service::PathResolverService;
             app_state.path_resolver = Some(Arc::new(PathResolverService::new(pool.clone())));
             tracing::info!("PathResolver service initialized");
         }
@@ -666,12 +667,12 @@ impl AppServiceFactory {
         {
             // CalDAV
             let calendar_repo: Arc<
-                dyn crate::domain::repositories::calendar_repository::CalendarRepository,
+                CalendarPgRepository,
             > = Arc::new(
                 crate::infrastructure::repositories::pg::CalendarPgRepository::new(pool.clone()),
             );
             let event_repo: Arc<
-                dyn crate::domain::repositories::calendar_event_repository::CalendarEventRepository,
+                CalendarEventPgRepository,
             > = Arc::new(
                 crate::infrastructure::repositories::pg::CalendarEventPgRepository::new(
                     pool.clone(),
@@ -690,22 +691,22 @@ impl AppServiceFactory {
             );
             app_state.calendar_use_case = Some(
                 calendar_service
-                    as Arc<dyn crate::application::ports::calendar_ports::CalendarUseCase>,
+                    as Arc<CalendarService>,
             );
 
             // CardDAV
             let address_book_repo: Arc<
-                dyn crate::domain::repositories::address_book_repository::AddressBookRepository,
+                AddressBookPgRepository,
             > = Arc::new(
                 crate::infrastructure::repositories::pg::AddressBookPgRepository::new(pool.clone()),
             );
             let contact_repo: Arc<
-                dyn crate::domain::repositories::contact_repository::ContactRepository,
+                ContactPgRepository,
             > = Arc::new(
                 crate::infrastructure::repositories::pg::ContactPgRepository::new(pool.clone()),
             );
             let group_repo: Arc<
-                dyn crate::domain::repositories::contact_repository::ContactGroupRepository,
+                ContactGroupPgRepository,
             > = Arc::new(
                 crate::infrastructure::repositories::pg::ContactGroupPgRepository::new(
                     pool.clone(),
@@ -718,12 +719,8 @@ impl AppServiceFactory {
                     group_repo,
                 )
             );
-            app_state.addressbook_use_case = Some(contact_storage.clone()
-                as Arc<dyn crate::application::ports::carddav_ports::AddressBookUseCase>);
-            app_state.contact_use_case = Some(
-                contact_storage
-                    as Arc<dyn crate::application::ports::carddav_ports::ContactUseCase>,
-            );
+            app_state.addressbook_use_case = Some(contact_storage.clone());
+            app_state.contact_use_case = Some(contact_storage);
 
             tracing::info!("CalDAV and CardDAV services initialized with PostgreSQL repositories");
         }
@@ -736,9 +733,6 @@ impl AppServiceFactory {
                     "WOPI is enabled but WOPI_DISCOVERY_URL is empty — WOPI services will NOT be available"
                 );
             } else {
-                use crate::application::services::wopi_lock_service::WopiLockService;
-                use crate::application::services::wopi_token_service::WopiTokenService;
-                use crate::infrastructure::services::wopi_discovery_service::WopiDiscoveryService;
 
                 let wopi_secret = if self.config.wopi.secret.is_empty() {
                     self.config.auth.jwt_secret.clone()
@@ -776,25 +770,25 @@ impl AppServiceFactory {
 #[derive(Clone)]
 pub struct CoreServices {
     pub path_service: Arc<PathService>,
-    pub file_content_cache: Arc<dyn ContentCachePort>,
-    pub thumbnail_service: Arc<dyn ThumbnailPort>,
-    pub chunked_upload_service: Arc<dyn ChunkedUploadPort>,
-    pub image_transcode_service: Arc<dyn ImageTranscodePort>,
-    pub dedup_service: Arc<dyn DedupPort>,
-    pub zip_service: Arc<dyn ZipPort>,
+    pub file_content_cache: Arc<FileContentCache>,
+    pub thumbnail_service: Arc<ThumbnailService>,
+    pub chunked_upload_service: Arc<ChunkedUploadService>,
+    pub image_transcode_service: Arc<ImageTranscodeService>,
+    pub dedup_service: Arc<DedupService>,
+    pub zip_service: Option<Arc<ZipService>>,
     pub config: AppConfig,
 }
 
 /// Container for repository services
 #[derive(Clone)]
 pub struct RepositoryServices {
-    pub folder_repository: Arc<dyn FolderStoragePort>,
+    pub folder_repository: Arc<FolderDbRepository>,
     pub folder_repo_concrete: Arc<FolderDbRepository>,
-    pub file_read_repository: Arc<dyn FileReadPort>,
-    pub file_write_repository: Arc<dyn FileWritePort>,
-    pub i18n_repository: Arc<dyn I18nService>,
+    pub file_read_repository: Arc<FileBlobReadRepository>,
+    pub file_write_repository: Arc<FileBlobWriteRepository>,
+    pub i18n_repository: Arc<FileSystemI18nService>,
     pub trash_repository:
-        Option<Arc<dyn crate::domain::repositories::trash_repository::TrashRepository>>,
+        Option<Arc<TrashDbRepository>>,
 }
 
 /// Container for application services
@@ -803,23 +797,23 @@ pub struct ApplicationServices {
     // Concrete types for compatibility with existing handlers
     pub folder_service_concrete: Arc<FolderService>,
     // Traits for abstraction
-    pub folder_service: Arc<dyn FolderUseCase>,
-    pub file_upload_service: Arc<dyn FileUploadUseCase>,
-    pub file_retrieval_service: Arc<dyn FileRetrievalUseCase>,
-    pub file_management_service: Arc<dyn FileManagementUseCase>,
+    pub folder_service: Arc<FolderService>,
+    pub file_upload_service: Arc<FileUploadService>,
+    pub file_retrieval_service: Arc<FileRetrievalService>,
+    pub file_management_service: Arc<FileManagementService>,
     pub file_use_case_factory: Arc<dyn FileUseCaseFactory>,
     pub i18n_service: Arc<I18nApplicationService>,
-    pub trash_service: Option<Arc<dyn TrashUseCase>>,
-    pub search_service: Option<Arc<dyn SearchUseCase>>,
-    pub share_service: Option<Arc<dyn crate::application::ports::share_ports::ShareUseCase>>,
-    pub favorites_service: Option<Arc<dyn FavoritesUseCase>>,
-    pub recent_service: Option<Arc<dyn RecentItemsUseCase>>,
+    pub trash_service: Option<Arc<TrashService>>,
+    pub search_service: Option<Arc<SearchService>>,
+    pub share_service: Option<Arc<ShareService>>,
+    pub favorites_service: Option<Arc<FavoritesService>>,
+    pub recent_service: Option<Arc<RecentService>>,
 }
 
 /// Container for authentication services
 #[derive(Clone)]
 pub struct AuthServices {
-    pub token_service: Arc<dyn crate::application::ports::auth_ports::TokenServicePort>,
+    pub token_service: Arc<JwtTokenService>,
     pub auth_application_service: Arc<AuthApplicationService>,
     pub login_lockout:
         Arc<crate::infrastructure::services::login_lockout_service::LoginLockoutService>,
@@ -836,19 +830,19 @@ pub struct AppState {
     pub maintenance_pool: Option<Arc<PgPool>>,
     pub auth_service: Option<AuthServices>,
     pub admin_settings_service: Option<Arc<AdminSettingsService>>,
-    pub trash_service: Option<Arc<dyn TrashUseCase>>,
-    pub share_service: Option<Arc<dyn crate::application::ports::share_ports::ShareUseCase>>,
-    pub favorites_service: Option<Arc<dyn FavoritesUseCase>>,
-    pub recent_service: Option<Arc<dyn RecentItemsUseCase>>,
+    pub trash_service: Option<Arc<TrashService>>,
+    pub share_service: Option<Arc<ShareService>>,
+    pub favorites_service: Option<Arc<FavoritesService>>,
+    pub recent_service: Option<Arc<RecentService>>,
     pub storage_usage_service:
-        Option<Arc<dyn crate::application::ports::storage_ports::StorageUsagePort>>,
-    pub calendar_service: Option<Arc<dyn crate::application::ports::storage_ports::StorageUseCase>>,
-    pub contact_service: Option<Arc<dyn crate::application::ports::storage_ports::StorageUseCase>>,
+        Option<Arc<StorageUsageService>>,
+    pub calendar_service: Option<Arc<CalendarService>>,
+    pub contact_service: Option<Arc<ContactStorageAdapter>>,
     pub calendar_use_case:
-        Option<Arc<dyn crate::application::ports::calendar_ports::CalendarUseCase>>,
+        Option<Arc<CalendarService>>,
     pub addressbook_use_case:
-        Option<Arc<dyn crate::application::ports::carddav_ports::AddressBookUseCase>>,
-    pub contact_use_case: Option<Arc<dyn crate::application::ports::carddav_ports::ContactUseCase>>,
+        Option<Arc<ContactStorageAdapter>>,
+    pub contact_use_case: Option<Arc<ContactStorageAdapter>>,
     pub wopi_token_service:
         Option<Arc<crate::application::services::wopi_token_service::WopiTokenService>>,
     pub wopi_lock_service:

src/common/stubs.rs

@@ -10,7 +10,6 @@ use std::path::{Path, PathBuf};
 use std::pin::Pin;
 use std::sync::Arc;
 
-use async_trait::async_trait;
 use bytes::Bytes;
 use futures::Stream;
 
@@ -23,7 +22,7 @@ use crate::application::dtos::search_dto::{
     SearchCriteriaDto, SearchResultsDto, SearchSuggestionsDto,
 };
 use crate::application::ports::file_ports::{
-    FileManagementUseCase, FileRetrievalUseCase, FileUploadUseCase, FileUseCaseFactory,
+    FileManagementUseCase, FileRetrievalUseCase, FileUploadUseCase,
     OptimizedFileContent,
 };
 use crate::application::ports::inbound::{FolderUseCase, SearchUseCase};
@@ -44,7 +43,6 @@ use crate::domain::services::path_service::StoragePath;
 /// are fully initialised.
 pub struct StubZipPort;
 
-#[async_trait]
 impl ZipPort for StubZipPort {
     async fn create_folder_zip(
         &self,
@@ -64,7 +62,6 @@ impl ZipPort for StubZipPort {
 
 pub struct StubFileReadPort;
 
-#[async_trait]
 impl FileReadPort for StubFileReadPort {
     async fn get_file(&self, _id: &str) -> Result<File, DomainError> {
         Ok(File::default())
@@ -136,7 +133,6 @@ impl FileReadPort for StubFileReadPort {
 
 pub struct StubFileWritePort;
 
-#[async_trait]
 impl FileWritePort for StubFileWritePort {
     async fn save_file_from_temp(
         &self,
@@ -218,7 +214,6 @@ impl FileWritePort for StubFileWritePort {
 
 pub struct StubFolderStoragePort;
 
-#[async_trait]
 impl FolderRepository for StubFolderStoragePort {
     async fn create_folder(
         &self,
@@ -324,7 +319,6 @@ impl FolderRepository for StubFolderStoragePort {
 
 pub struct StubI18nService;
 
-#[async_trait]
 impl I18nService for StubI18nService {
     async fn translate(&self, _key: &str, _locale: Locale) -> I18nResult<String> {
         Ok(String::new())
@@ -349,7 +343,6 @@ impl I18nService for StubI18nService {
 
 pub struct StubFolderUseCase;
 
-#[async_trait]
 impl FolderUseCase for StubFolderUseCase {
     async fn create_folder(&self, _dto: CreateFolderDto) -> Result<FolderDto, DomainError> {
         Ok(FolderDto::default())
@@ -429,7 +422,6 @@ impl FolderUseCase for StubFolderUseCase {
 
 pub struct StubFileUploadUseCase;
 
-#[async_trait]
 impl FileUploadUseCase for StubFileUploadUseCase {
     async fn upload_file_streaming(
         &self,
@@ -486,7 +478,6 @@ impl FileUploadUseCase for StubFileUploadUseCase {
 
 pub struct StubFileRetrievalUseCase;
 
-#[async_trait]
 impl FileRetrievalUseCase for StubFileRetrievalUseCase {
     async fn get_file(&self, _id: &str) -> Result<FileDto, DomainError> {
         Ok(FileDto::default())
@@ -548,7 +539,6 @@ impl FileRetrievalUseCase for StubFileRetrievalUseCase {
 
 pub struct StubFileManagementUseCase;
 
-#[async_trait]
 impl FileManagementUseCase for StubFileManagementUseCase {
     async fn move_file(
         &self,
@@ -579,33 +569,12 @@ impl FileManagementUseCase for StubFileManagementUseCase {
     }
 }
 
-// ---------------------------------------------------------------------------
-// FileUseCaseFactory
-// ---------------------------------------------------------------------------
-
-pub struct StubFileUseCaseFactory;
-
-impl FileUseCaseFactory for StubFileUseCaseFactory {
-    fn create_file_upload_use_case(&self) -> Arc<dyn FileUploadUseCase> {
-        Arc::new(StubFileUploadUseCase)
-    }
-
-    fn create_file_retrieval_use_case(&self) -> Arc<dyn FileRetrievalUseCase> {
-        Arc::new(StubFileRetrievalUseCase)
-    }
-
-    fn create_file_management_use_case(&self) -> Arc<dyn FileManagementUseCase> {
-        Arc::new(StubFileManagementUseCase)
-    }
-}
-
 // ---------------------------------------------------------------------------
 // SearchUseCase
 // ---------------------------------------------------------------------------
 
 pub struct StubSearchUseCase;
 
-#[async_trait]
 impl SearchUseCase for StubSearchUseCase {
     async fn search(
         &self,
@@ -642,7 +611,6 @@ use crate::application::ports::dedup_ports::{
 
 pub struct StubDedupPort;
 
-#[async_trait]
 impl DedupPort for StubDedupPort {
     async fn store_bytes(
         &self,
@@ -741,7 +709,6 @@ use crate::application::ports::cache_ports::{
 
 pub struct StubMetadataCachePort;
 
-#[async_trait]
 impl MetadataCachePort for StubMetadataCachePort {
     async fn get_metadata(&self, _path: &Path) -> Option<CachedMetadataDto> {
         None
@@ -774,7 +741,6 @@ impl MetadataCachePort for StubMetadataCachePort {
 
 pub struct StubContentCachePort;
 
-#[async_trait]
 impl ContentCachePort for StubContentCachePort {
     fn should_cache(&self, _size: usize) -> bool {
         false

src/domain/repositories/address_book_repository.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use std::result::Result;
 use uuid::Uuid;
 
@@ -7,7 +6,6 @@ use crate::domain::entities::contact::AddressBook;
 
 pub type AddressBookRepositoryResult<T> = Result<T, DomainError>;
 
-#[async_trait]
 pub trait AddressBookRepository: Send + Sync + 'static {
     async fn create_address_book(
         &self,

src/domain/repositories/calendar_event_repository.rs

@@ -1,13 +1,11 @@
 use crate::common::errors::DomainError;
 use crate::domain::entities::calendar_event::CalendarEvent;
-use async_trait::async_trait;
 use chrono::{DateTime, Utc};
 use uuid::Uuid;
 
 pub type CalendarEventRepositoryResult<T> = Result<T, DomainError>;
 
 /// Repository interface for CalendarEvent entity operations
-#[async_trait]
 pub trait CalendarEventRepository: Send + Sync + 'static {
     /// Creates a new calendar event
     async fn create_event(

src/domain/repositories/calendar_repository.rs

@@ -1,12 +1,10 @@
 use crate::common::errors::DomainError;
 use crate::domain::entities::calendar::Calendar;
-use async_trait::async_trait;
 use uuid::Uuid;
 
 pub type CalendarRepositoryResult<T> = Result<T, DomainError>;
 
 /// Repository interface for Calendar entity operations
-#[async_trait]
 pub trait CalendarRepository: Send + Sync + 'static {
     /// Creates a new calendar
     async fn create_calendar(&self, calendar: Calendar) -> CalendarRepositoryResult<Calendar>;

src/domain/repositories/contact_repository.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use std::result::Result;
 use uuid::Uuid;
 
@@ -7,7 +6,6 @@ use crate::domain::entities::contact::{Contact, ContactGroup};
 
 pub type ContactRepositoryResult<T> = Result<T, DomainError>;
 
-#[async_trait]
 pub trait ContactRepository: Send + Sync + 'static {
     async fn create_contact(&self, contact: Contact) -> ContactRepositoryResult<Contact>;
     async fn update_contact(&self, contact: Contact) -> ContactRepositoryResult<Contact>;
@@ -32,7 +30,6 @@ pub trait ContactRepository: Send + Sync + 'static {
     ) -> ContactRepositoryResult<Vec<Contact>>;
 }
 
-#[async_trait]
 pub trait ContactGroupRepository: Send + Sync + 'static {
     async fn create_group(&self, group: ContactGroup) -> ContactRepositoryResult<ContactGroup>;
     async fn update_group(&self, group: ContactGroup) -> ContactRepositoryResult<ContactGroup>;

src/domain/repositories/file_repository.rs

@@ -10,7 +10,6 @@
 
 use std::path::PathBuf;
 
-use async_trait::async_trait;
 use bytes::Bytes;
 use futures::Stream;
 
@@ -26,7 +25,6 @@ use crate::domain::services::path_service::StoragePath;
 ///
 /// Encapsulates every operation that queries state without modifying it:
 /// get, list, content, stream, mmap, range, path resolution.
-#[async_trait]
 pub trait FileReadRepository: Send + Sync + 'static {
     /// Gets a file by its ID.
     async fn get_file(&self, id: &str) -> Result<File, DomainError>;
@@ -63,7 +61,6 @@ pub trait FileReadRepository: Send + Sync + 'static {
 ///
 /// Covers: upload (buffered + streaming), move, delete, update,
 /// and deferred registration for write-behind cache.
-#[async_trait]
 pub trait FileWriteRepository: Send + Sync + 'static {
     /// Saves a new file from bytes.
     async fn save_file(

src/domain/repositories/folder_repository.rs

@@ -8,7 +8,6 @@
 //! Concrete implementations (filesystem, PostgreSQL, S3, etc.) live in
 //! the infrastructure layer.
 
-use async_trait::async_trait;
 
 use crate::common::errors::DomainError;
 use crate::domain::entities::folder::Folder;
@@ -18,7 +17,6 @@ use crate::domain::services::path_service::StoragePath;
 ///
 /// Defines the CRUD and management operations required for
 /// the Folder entity in the storage system.
-#[async_trait]
 pub trait FolderRepository: Send + Sync + 'static {
     /// Creates a new folder
     async fn create_folder(

src/domain/repositories/session_repository.rs

@@ -1,6 +1,5 @@
 use crate::common::errors::DomainError;
 use crate::domain::entities::session::Session;
-use async_trait::async_trait;
 
 #[derive(Debug, thiserror::Error)]
 pub enum SessionRepositoryError {
@@ -29,7 +28,6 @@ impl From<SessionRepositoryError> for DomainError {
     }
 }
 
-#[async_trait]
 pub trait SessionRepository: Send + Sync + 'static {
     /// Creates a new session
     async fn create_session(&self, session: Session) -> SessionRepositoryResult<Session>;

src/domain/repositories/settings_repository.rs

@@ -1,10 +1,8 @@
 use crate::common::errors::DomainError;
-use async_trait::async_trait;
 use std::collections::HashMap;
 
 /// Repository for platform settings stored in the database.
 /// Settings are key-value pairs organized by category (e.g., "oidc", "general").
-#[async_trait]
 pub trait SettingsRepository: Send + Sync + 'static {
     /// Get a single setting value by key
     async fn get(&self, key: &str) -> Result<Option<String>, DomainError>;

src/domain/repositories/share_repository.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use thiserror::Error;
 
 use crate::domain::{
@@ -20,7 +19,6 @@ pub enum ShareRepositoryError {
     AlreadyExists(String),
 }
 
-#[async_trait]
 pub trait ShareRepository: Send + Sync + 'static {
     /// Save a new share or update an existing one
     async fn save(&self, share: &Share) -> Result<Share, ShareRepositoryError>;

src/domain/repositories/trash_repository.rs

@@ -1,10 +1,8 @@
-use async_trait::async_trait;
 use uuid::Uuid;
 
 use crate::common::errors::Result;
 use crate::domain::entities::trashed_item::TrashedItem;
 
-#[async_trait]
 pub trait TrashRepository: Send + Sync {
     async fn add_to_trash(&self, item: &TrashedItem) -> Result<()>;
     async fn get_trash_items(&self, user_id: &Uuid) -> Result<Vec<TrashedItem>>;

src/domain/repositories/user_repository.rs

@@ -1,6 +1,5 @@
 use crate::common::errors::DomainError;
 use crate::domain::entities::user::{User, UserRole};
-use async_trait::async_trait;
 
 #[derive(Debug, thiserror::Error)]
 pub enum UserRepositoryError {
@@ -41,7 +40,6 @@ impl From<UserRepositoryError> for DomainError {
     }
 }
 
-#[async_trait]
 pub trait UserRepository: Send + Sync + 'static {
     /// Creates a new user
     async fn create_user(&self, user: User) -> UserRepositoryResult<User>;

src/domain/services/i18n_service.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use thiserror::Error;
 
 /// Error types for i18n service operations
@@ -54,7 +53,6 @@ impl Locale {
 }
 
 /// Interface for i18n service (primary port)
-#[async_trait]
 pub trait I18nService: Send + Sync + 'static {
     /// Get a translation for a key and locale
     async fn translate(&self, key: &str, locale: Locale) -> I18nResult<String>;

src/infrastructure/adapters/calendar_storage_adapter.rs

@@ -4,7 +4,6 @@
 //! the `CalendarRepository` and `CalendarEventRepository` domain repositories.
 //! It bridges the gap between the application layer and the infrastructure layer.
 
-use async_trait::async_trait;
 use chrono::{DateTime, Utc};
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -20,18 +19,20 @@ use crate::domain::entities::calendar::Calendar;
 use crate::domain::entities::calendar_event::CalendarEvent;
 use crate::domain::repositories::calendar_event_repository::CalendarEventRepository;
 use crate::domain::repositories::calendar_repository::CalendarRepository;
+use crate::infrastructure::repositories::pg::CalendarEventPgRepository;
+use crate::infrastructure::repositories::pg::CalendarPgRepository;
 
 /// Adapter that implements CalendarStoragePort using domain repositories
 pub struct CalendarStorageAdapter {
-    calendar_repository: Arc<dyn CalendarRepository>,
-    event_repository: Arc<dyn CalendarEventRepository>,
+    calendar_repository: Arc<CalendarPgRepository>,
+    event_repository: Arc<CalendarEventPgRepository>,
 }
 
 impl CalendarStorageAdapter {
     /// Creates a new CalendarStorageAdapter with the given repositories
     pub fn new(
-        calendar_repository: Arc<dyn CalendarRepository>,
-        event_repository: Arc<dyn CalendarEventRepository>,
+        calendar_repository: Arc<CalendarPgRepository>,
+        event_repository: Arc<CalendarEventPgRepository>,
     ) -> Self {
         Self {
             calendar_repository,
@@ -40,7 +41,6 @@ impl CalendarStorageAdapter {
     }
 }
 
-#[async_trait]
 impl CalendarStoragePort for CalendarStorageAdapter {
     // Calendar operations
 

src/infrastructure/adapters/contact_storage_adapter.rs

@@ -4,7 +4,6 @@
 //! using the domain repositories. It bridges the gap between the application layer
 //! and the infrastructure layer for CardDAV functionality.
 
-use async_trait::async_trait;
 use std::sync::Arc;
 use uuid::Uuid;
 
@@ -22,20 +21,23 @@ use crate::common::errors::{DomainError, ErrorKind};
 use crate::domain::entities::contact::{Address, AddressBook, Contact, ContactGroup, Email, Phone};
 use crate::domain::repositories::address_book_repository::AddressBookRepository;
 use crate::domain::repositories::contact_repository::{ContactGroupRepository, ContactRepository};
+use crate::infrastructure::repositories::pg::AddressBookPgRepository;
+use crate::infrastructure::repositories::pg::ContactGroupPgRepository;
+use crate::infrastructure::repositories::pg::ContactPgRepository;
 
 /// Adapter that implements AddressBookUseCase and ContactUseCase using domain repositories
 pub struct ContactStorageAdapter {
-    address_book_repository: Arc<dyn AddressBookRepository>,
-    contact_repository: Arc<dyn ContactRepository>,
-    group_repository: Arc<dyn ContactGroupRepository>,
+    address_book_repository: Arc<AddressBookPgRepository>,
+    contact_repository: Arc<ContactPgRepository>,
+    group_repository: Arc<ContactGroupPgRepository>,
 }
 
 impl ContactStorageAdapter {
     /// Creates a new ContactStorageAdapter with the given repositories
     pub fn new(
-        address_book_repository: Arc<dyn AddressBookRepository>,
-        contact_repository: Arc<dyn ContactRepository>,
-        group_repository: Arc<dyn ContactGroupRepository>,
+        address_book_repository: Arc<AddressBookPgRepository>,
+        contact_repository: Arc<ContactPgRepository>,
+        group_repository: Arc<ContactGroupPgRepository>,
     ) -> Self {
         Self {
             address_book_repository,
@@ -217,7 +219,6 @@ impl ContactStorageAdapter {
     }
 }
 
-#[async_trait]
 impl AddressBookUseCase for ContactStorageAdapter {
     async fn create_address_book(
         &self,
@@ -423,7 +424,6 @@ impl AddressBookUseCase for ContactStorageAdapter {
     }
 }
 
-#[async_trait]
 impl ContactUseCase for ContactStorageAdapter {
     async fn create_contact(&self, dto: CreateContactDto) -> Result<ContactDto, DomainError> {
         let address_book_id = Self::parse_uuid(&dto.address_book_id, "AddressBook")?;

src/infrastructure/auth_factory.rs

@@ -3,7 +3,6 @@ use std::sync::Arc;
 
 type Result<T> = std::result::Result<T, Box<dyn std::error::Error + Send + Sync>>;
 
-use crate::application::ports::auth_ports::TokenServicePort;
 use crate::application::services::auth_application_service::AuthApplicationService;
 use crate::application::services::folder_service::FolderService;
 use crate::common::config::AppConfig;
@@ -19,7 +18,7 @@ pub async fn create_auth_services(
     folder_service: Option<Arc<FolderService>>,
 ) -> Result<AuthServices> {
     // Create JWT token service (TokenServicePort implementation)
-    let token_service: Arc<dyn TokenServicePort> = Arc::new(JwtTokenService::new(
+    let token_service: Arc<JwtTokenService> = Arc::new(JwtTokenService::new(
         config.auth.jwt_secret.clone(),
         config.auth.access_token_expiry_secs,
         config.auth.refresh_token_expiry_secs,

src/infrastructure/repositories/pg/address_book_pg_repository.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use chrono::Utc;
 use sqlx::{PgPool, Row, types::Uuid};
 use std::sync::Arc;
@@ -19,7 +18,6 @@ impl AddressBookPgRepository {
     }
 }
 
-#[async_trait]
 impl AddressBookRepository for AddressBookPgRepository {
     async fn create_address_book(
         &self,

src/infrastructure/repositories/pg/app_password_pg_repository.rs

@@ -3,7 +3,6 @@
 use crate::application::ports::auth_ports::AppPasswordStoragePort;
 use crate::common::errors::DomainError;
 use crate::domain::entities::app_password::AppPassword;
-use async_trait::async_trait;
 use chrono::{DateTime, Utc};
 use sqlx::PgPool;
 use std::sync::Arc;
@@ -22,7 +21,6 @@ impl AppPasswordPgRepository {
     }
 }
 
-#[async_trait]
 impl AppPasswordStoragePort for AppPasswordPgRepository {
     async fn create(&self, ap: AppPassword) -> Result<AppPassword, DomainError> {
         sqlx::query(

src/infrastructure/repositories/pg/calendar_event_pg_repository.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use chrono::{DateTime, Utc};
 use sqlx::{PgPool, Row, types::Uuid};
 use std::sync::Arc;
@@ -19,7 +18,6 @@ impl CalendarEventPgRepository {
     }
 }
 
-#[async_trait]
 impl CalendarEventRepository for CalendarEventPgRepository {
     async fn create_event(
         &self,

src/infrastructure/repositories/pg/calendar_pg_repository.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use chrono::Utc;
 use sqlx::{PgPool, Row, types::Uuid};
 use std::sync::Arc;
@@ -19,7 +18,6 @@ impl CalendarPgRepository {
     }
 }
 
-#[async_trait]
 impl CalendarRepository for CalendarPgRepository {
     async fn create_calendar(&self, calendar: Calendar) -> CalendarRepositoryResult<Calendar> {
         let row = sqlx::query(

src/infrastructure/repositories/pg/contact_group_pg_repository.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use chrono::Utc;
 use serde_json::Value as JsonValue;
 use sqlx::{PgPool, Row, types::Uuid};
@@ -24,7 +23,6 @@ impl ContactGroupPgRepository {
     }
 }
 
-#[async_trait]
 impl ContactGroupRepository for ContactGroupPgRepository {
     async fn create_group(&self, group: ContactGroup) -> ContactRepositoryResult<ContactGroup> {
         sqlx::query(

src/infrastructure/repositories/pg/contact_pg_repository.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use chrono::Utc;
 use serde_json::Value as JsonValue;
 use sqlx::{PgPool, Row, types::Uuid};
@@ -63,7 +62,6 @@ impl ContactPgRepository {
     }
 }
 
-#[async_trait]
 impl ContactRepository for ContactPgRepository {
     async fn create_contact(&self, contact: Contact) -> ContactRepositoryResult<Contact> {
         // Convert domain entities to persistence DTOs for JSONB serialization

src/infrastructure/repositories/pg/device_code_pg_repository.rs

@@ -1,6 +1,5 @@
 //! PostgreSQL repository for Device Authorization Grant (RFC 8628) codes.
 
-use async_trait::async_trait;
 use sqlx::{PgPool, Row};
 use std::sync::Arc;
 
@@ -49,7 +48,6 @@ impl DeviceCodePgRepository {
     }
 }
 
-#[async_trait]
 impl DeviceCodeStoragePort for DeviceCodePgRepository {
     async fn create_device_code(&self, dc: DeviceCode) -> Result<DeviceCode, DomainError> {
         sqlx::query(

src/infrastructure/repositories/pg/favorites_pg_repository.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use sqlx::{PgPool, Row};
 use std::sync::Arc;
 use tracing::error;
@@ -19,7 +18,6 @@ impl FavoritesPgRepository {
     }
 }
 
-#[async_trait]
 impl FavoritesRepositoryPort for FavoritesPgRepository {
     async fn get_favorites(&self, user_id: &str) -> Result<Vec<FavoriteItemDto>> {
         let user_uuid = Uuid::parse_str(user_id)?;

src/infrastructure/repositories/pg/file_blob_read_repository.rs

@@ -7,7 +7,6 @@
 //! File paths are resolved by JOINing with `storage.folders.path` (the
 //! materialized path column), so no recursive CTEs or N+1 queries are needed.
 
-use async_trait::async_trait;
 use bytes::Bytes;
 use futures::{Stream, TryStreamExt};
 use moka::sync::Cache;
@@ -17,16 +16,16 @@ use std::sync::Arc;
 use std::time::Duration;
 
 use crate::application::dtos::search_dto::SearchCriteriaDto;
-use crate::application::ports::dedup_ports::DedupPort;
 use crate::application::ports::storage_ports::FileReadPort;
 use crate::common::errors::DomainError;
 use crate::domain::entities::file::File;
 use crate::domain::services::path_service::StoragePath;
+use crate::infrastructure::services::dedup_service::DedupService;
 
 /// File read repository backed by PostgreSQL metadata + blob storage.
 pub struct FileBlobReadRepository {
     pool: Arc<PgPool>,
-    dedup: Arc<dyn DedupPort>,
+    dedup: Arc<DedupService>,
     /// Lock-free cache: file_id → blob_hash.
     /// Populated by `get_file()` and `resolve_blob_hash()` (slow path).
     /// Entries persist until TTI expiry (30 s idle) or capacity eviction —
@@ -37,7 +36,7 @@ pub struct FileBlobReadRepository {
 impl FileBlobReadRepository {
     pub fn new(
         pool: Arc<PgPool>,
-        dedup: Arc<dyn DedupPort>,
+        dedup: Arc<DedupService>,
         _folder_repo: Arc<super::folder_db_repository::FolderDbRepository>,
     ) -> Self {
         Self {
@@ -115,7 +114,6 @@ impl FileBlobReadRepository {
     }
 }
 
-#[async_trait]
 impl FileReadPort for FileBlobReadRepository {
     async fn get_file(&self, id: &str) -> Result<File, DomainError> {
         let row = sqlx::query_as::<
@@ -890,14 +888,13 @@ impl FileReadPort for FileBlobReadRepository {
 mod tests {
     use super::*;
     use crate::common::stubs::StubDedupPort;
-    use crate::infrastructure::repositories::pg::folder_db_repository::FolderDbRepository;
 
     /// Helper: build a `FileBlobReadRepository` without a real PgPool.
     /// Only the moka `hash_cache` is exercised — no SQL is executed.
     fn make_repo() -> FileBlobReadRepository {
         let _folder_repo = Arc::new(FolderDbRepository::new_stub());
         // StubDedupPort satisfies the trait but is never called in cache-only tests
-        let dedup: Arc<dyn DedupPort> = Arc::new(StubDedupPort);
+        let dedup: Arc<DedupService> = Arc::new(StubDedupPort);
         // PgPool is required by the struct but we won't hit any SQL in these tests.
         // We create a repo with a stub pool placeholder — only hash_cache is tested.
         FileBlobReadRepository {

src/infrastructure/repositories/pg/file_blob_write_repository.rs

@@ -7,30 +7,29 @@
 //! File paths are resolved by querying the materialized `storage.folders.path`
 //! column (O(1) per lookup), so no recursive CTEs are needed.
 
-use async_trait::async_trait;
 use sqlx::PgPool;
 use std::path::PathBuf;
 use std::sync::Arc;
 
-use crate::application::ports::dedup_ports::DedupPort;
 use crate::application::ports::storage_ports::{CopyFolderTreeResult, FileWritePort};
 use crate::common::errors::DomainError;
 use crate::domain::entities::file::File;
 use crate::domain::services::path_service::StoragePath;
 
 use super::folder_db_repository::FolderDbRepository;
+use crate::infrastructure::services::dedup_service::DedupService;
 
 /// File write repository backed by PostgreSQL metadata + blob storage.
 pub struct FileBlobWriteRepository {
     pool: Arc<PgPool>,
-    dedup: Arc<dyn DedupPort>,
+    dedup: Arc<DedupService>,
     folder_repo: Arc<FolderDbRepository>,
 }
 
 impl FileBlobWriteRepository {
     pub fn new(
         pool: Arc<PgPool>,
-        dedup: Arc<dyn DedupPort>,
+        dedup: Arc<DedupService>,
         folder_repo: Arc<FolderDbRepository>,
     ) -> Self {
         Self {
@@ -180,7 +179,6 @@ impl FileBlobWriteRepository {
     }
 }
 
-#[async_trait]
 impl FileWritePort for FileBlobWriteRepository {
     async fn save_file_from_temp(
         &self,

src/infrastructure/repositories/pg/folder_db_repository.rs

@@ -8,7 +8,6 @@
 //! database triggers, so reading a folder's full path is always O(1) — no
 //! recursive CTEs or N+1 queries.
 
-use async_trait::async_trait;
 use sqlx::PgPool;
 use std::sync::Arc;
 
@@ -72,7 +71,6 @@ impl FolderDbRepository {
     }
 }
 
-#[async_trait]
 impl FolderRepository for FolderDbRepository {
     async fn create_folder(
         &self,

src/infrastructure/repositories/pg/recent_items_pg_repository.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use sqlx::{PgPool, Row};
 use std::sync::Arc;
 use tracing::error;
@@ -19,7 +18,6 @@ impl RecentItemsPgRepository {
     }
 }
 
-#[async_trait]
 impl RecentItemsRepositoryPort for RecentItemsPgRepository {
     async fn get_recent_items(&self, user_id: &str, limit: i32) -> Result<Vec<RecentItemDto>> {
         let user_uuid = Uuid::parse_str(user_id)?;

src/infrastructure/repositories/pg/session_pg_repository.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use chrono::Utc;
 use futures::future::BoxFuture;
 use sqlx::{PgPool, Row};
@@ -39,7 +38,6 @@ impl SessionPgRepository {
     }
 }
 
-#[async_trait]
 impl SessionRepository for SessionPgRepository {
     /// Creates a new session using a transaction
     async fn create_session(&self, session: Session) -> SessionRepositoryResult<Session> {
@@ -291,7 +289,6 @@ impl SessionRepository for SessionPgRepository {
 }
 
 // Implementation of the storage port for the application layer
-#[async_trait]
 impl SessionStoragePort for SessionPgRepository {
     async fn create_session(&self, session: Session) -> Result<Session, DomainError> {
         SessionRepository::create_session(self, session)

src/infrastructure/repositories/pg/settings_pg_repository.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use sqlx::PgPool;
 use std::collections::HashMap;
 use std::sync::Arc;
@@ -16,7 +15,6 @@ impl SettingsPgRepository {
     }
 }
 
-#[async_trait]
 impl SettingsRepository for SettingsPgRepository {
     async fn get(&self, key: &str) -> Result<Option<String>, DomainError> {
         let row =

src/infrastructure/repositories/pg/share_pg_repository.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use sqlx::{PgPool, Row};
 use std::sync::Arc;
 
@@ -72,7 +71,6 @@ impl SharePgRepository {
     }
 }
 
-#[async_trait]
 impl ShareStoragePort for SharePgRepository {
     async fn save_share(&self, share: &Share) -> Result<Share, DomainError> {
         let row = sqlx::query(

src/infrastructure/repositories/pg/trash_db_repository.rs

@@ -4,7 +4,6 @@
 //! and `storage.folders`.  There is no separate trash table — trashed items
 //! are files/folders with `is_trashed = TRUE`.
 
-use async_trait::async_trait;
 use chrono::{DateTime, Utc};
 use sqlx::PgPool;
 use std::sync::Arc;
@@ -65,7 +64,6 @@ impl TrashDbRepository {
     }
 }
 
-#[async_trait]
 impl TrashRepository for TrashDbRepository {
     async fn add_to_trash(&self, _item: &TrashedItem) -> Result<()> {
         // No-op: the actual flagging is done by FileWritePort::move_to_trash

src/infrastructure/repositories/pg/user_pg_repository.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use futures::future::BoxFuture;
 use sqlx::{PgPool, Row};
 use std::sync::Arc;
@@ -44,7 +43,6 @@ impl UserPgRepository {
     }
 }
 
-#[async_trait]
 impl UserRepository for UserPgRepository {
     /// Creates a new user using a transaction
     async fn create_user(&self, user: User) -> UserRepositoryResult<User> {
@@ -619,7 +617,6 @@ impl UserRepository for UserPgRepository {
 }
 
 // Storage port implementation for the application layer
-#[async_trait]
 impl UserStoragePort for UserPgRepository {
     async fn create_user(&self, user: User) -> Result<User, DomainError> {
         UserRepository::create_user(self, user)

src/infrastructure/services/chunked_upload_service.rs

@@ -15,7 +15,6 @@
 //! 3. HEAD /api/uploads/:id  → Check progress
 //! 4. POST /api/uploads/:id/complete → Finalize and assemble
 
-use async_trait::async_trait;
 use chrono::{DateTime, Utc};
 use dashmap::DashMap;
 use serde::{Deserialize, Serialize};
@@ -763,7 +762,6 @@ impl ChunkedUploadService {
 
 // ─── Port implementation ─────────────────────────────────────────────────────
 
-#[async_trait]
 impl ChunkedUploadPort for ChunkedUploadService {
     async fn create_session(
         &self,

src/infrastructure/services/compression_service.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use bytes::Bytes;
 use flate2::Compression;
 use flate2::bufread::GzDecoder;
@@ -43,7 +42,6 @@ impl From<CompressionLevel> for Compression {
 const COMPRESSION_SIZE_THRESHOLD: u64 = 1024 * 50; // 50KB
 
 /// Interface for compression services
-#[async_trait]
 pub trait CompressionService: Send + Sync {
     /// Compresses data in memory
     async fn compress_data(&self, data: &[u8], level: CompressionLevel) -> io::Result<Vec<u8>>;
@@ -88,7 +86,6 @@ impl GzipCompressionService {
     }
 }
 
-#[async_trait]
 impl CompressionService for GzipCompressionService {
     /// Compresses data in memory using Gzip
     async fn compress_data(&self, data: &[u8], level: CompressionLevel) -> io::Result<Vec<u8>> {
@@ -258,7 +255,6 @@ impl From<PortCompressionLevel> for CompressionLevel {
     }
 }
 
-#[async_trait]
 impl CompressionPort for GzipCompressionService {
     async fn compress_data(
         &self,

src/infrastructure/services/dedup_service.rs

@@ -31,7 +31,6 @@
 //! - 30-50% storage reduction typical
 //! - Faster uploads for existing content (instant dedup)
 
-use async_trait::async_trait;
 use bytes::Bytes;
 use futures::stream::{self, StreamExt};
 use futures::{Stream, TryStreamExt};
@@ -825,7 +824,6 @@ impl DedupService {
 
 // ─── Port implementation ─────────────────────────────────────────────────────
 
-#[async_trait]
 impl DedupPort for DedupService {
     async fn store_bytes(
         &self,

src/infrastructure/services/file_content_cache.rs

@@ -198,9 +198,7 @@ pub type SharedFileContentCache = Arc<FileContentCache>;
 // ─── ContentCachePort implementation ─────────────────────────
 
 use crate::application::ports::cache_ports::ContentCachePort;
-use async_trait::async_trait;
 
-#[async_trait]
 impl ContentCachePort for FileContentCache {
     fn should_cache(&self, size: usize) -> bool {
         FileContentCache::should_cache(self, size)

src/infrastructure/services/file_system_i18n_service.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use serde_json::Value;
 use std::collections::HashMap;
 use std::path::PathBuf;
@@ -63,7 +62,6 @@ impl FileSystemI18nService {
     }
 }
 
-#[async_trait]
 impl I18nService for FileSystemI18nService {
     async fn translate(&self, key: &str, locale: Locale) -> I18nResult<String> {
         // Check if translations are cached

src/infrastructure/services/image_transcode_service.rs

@@ -10,7 +10,6 @@
 //! - Supports JPEG, PNG, GIF → WebP conversion
 //! - Falls back to original if conversion fails or result is larger
 
-use async_trait::async_trait;
 use bytes::Bytes;
 use image::ImageFormat;
 use std::path::{Path, PathBuf};
@@ -392,7 +391,6 @@ impl From<PortOutputFormat> for OutputFormat {
     }
 }
 
-#[async_trait]
 impl ImageTranscodePort for ImageTranscodeService {
     fn can_transcode(&self, mime_type: &str) -> bool {
         ImageTranscodeService::can_transcode(mime_type)

src/infrastructure/services/oidc_service.rs

@@ -5,7 +5,6 @@
 //! Supports both RSA (RS256, RS384, RS512) and EC (ES256, ES384) algorithms.
 //! Compatible with Authentik, Keycloak, and any standard OIDC provider.
 
-use async_trait::async_trait;
 use serde::Deserialize;
 use std::sync::RwLock;
 use std::time::{Duration, Instant};
@@ -293,7 +292,6 @@ impl OidcService {
     }
 }
 
-#[async_trait]
 impl OidcServicePort for OidcService {
     async fn get_authorize_url(
         &self,

src/infrastructure/services/password_hasher.rs

@@ -12,7 +12,6 @@
 
 use argon2::password_hash::SaltString;
 use argon2::{Algorithm, Argon2, Params, PasswordHash, PasswordHasher, PasswordVerifier, Version};
-use async_trait::async_trait;
 use rand_core::OsRng;
 
 use crate::application::ports::auth_ports::PasswordHasherPort;
@@ -57,7 +56,6 @@ impl Argon2PasswordHasher {
     }
 }
 
-#[async_trait]
 impl PasswordHasherPort for Argon2PasswordHasher {
     async fn hash_password(&self, password: &str) -> Result<String, DomainError> {
         let pwd = password.to_owned();

src/infrastructure/services/path_service.rs

@@ -5,7 +5,6 @@
 //!
 //! StoragePath (Value Object) remains in domain/services/path_service.rs
 
-use async_trait::async_trait;
 use std::path::{Path, PathBuf};
 use tokio::fs;
 
@@ -116,7 +115,6 @@ impl PathService {
     }
 }
 
-#[async_trait]
 impl StoragePort for PathService {
     fn resolve_path(&self, storage_path: &StoragePath) -> PathBuf {
         let mut path = self.root_path.clone();

src/infrastructure/services/thumbnail_service.rs

@@ -1,4 +1,3 @@
-use async_trait::async_trait;
 use bytes::Bytes;
 use image::{ImageFormat, imageops::FilterType};
 /**
@@ -458,7 +457,6 @@ impl From<PortThumbnailSize> for ThumbnailSize {
     }
 }
 
-#[async_trait]
 impl ThumbnailPort for ThumbnailService {
     fn is_supported_image(&self, mime_type: &str) -> bool {
         ThumbnailService::is_supported_image(mime_type)

src/infrastructure/services/trash_cleanup_service.rs

@@ -5,6 +5,7 @@ use tracing::{debug, error, info, instrument};
 
 use crate::common::errors::Result;
 use crate::domain::repositories::trash_repository::TrashRepository;
+use crate::infrastructure::repositories::pg::trash_db_repository::TrashDbRepository;
 
 /// Service for automatic cleanup of expired items in the trash.
 ///
@@ -12,12 +13,12 @@ use crate::domain::repositories::trash_repository::TrashRepository;
 /// in **2 SQL statements inside a single transaction**, instead of the
 /// previous N+1 pattern that issued 3 queries per expired item.
 pub struct TrashCleanupService {
-    trash_repository: Arc<dyn TrashRepository>,
+    trash_repository: Arc<TrashDbRepository>,
     cleanup_interval_hours: u64,
 }
 
 impl TrashCleanupService {
-    pub fn new(trash_repository: Arc<dyn TrashRepository>, cleanup_interval_hours: u64) -> Self {
+    pub fn new(trash_repository: Arc<TrashDbRepository>, cleanup_interval_hours: u64) -> Self {
         Self {
             trash_repository,
             cleanup_interval_hours: cleanup_interval_hours.max(1), // Minimum 1 hour
@@ -57,7 +58,7 @@ impl TrashCleanupService {
 
     /// Bulk-delete all expired trash items in a single transaction.
     #[instrument(skip(trash_repository))]
-    async fn cleanup_expired_items(trash_repository: Arc<dyn TrashRepository>) -> Result<()> {
+    async fn cleanup_expired_items(trash_repository: Arc<TrashDbRepository>) -> Result<()> {
         debug!("Starting bulk cleanup of expired trash items");
 
         let (files, folders) = trash_repository.delete_expired_bulk().await?;

src/infrastructure/services/zip_service.rs

@@ -5,7 +5,6 @@ use crate::{
     application::ports::zip_ports::ZipPort,
     common::errors::{DomainError, ErrorKind, Result},
 };
-use async_trait::async_trait;
 use async_zip::base::write::ZipFileWriter;
 use async_zip::{Compression, ZipEntryBuilder};
 use futures::StreamExt;
@@ -17,6 +16,8 @@ use thiserror::Error;
 use tokio::io::BufWriter;
 use tokio_util::compat::Compat;
 use tracing::*;
+use crate::application::services::file_retrieval_service::FileRetrievalService;
+use crate::application::services::folder_service::FolderService;
 
 /// Error related to ZIP file creation
 #[derive(Debug, Error)]
@@ -53,15 +54,15 @@ type AsyncZipWriter = ZipFileWriter<Compat<BufWriter<tokio::fs::File>>>;
 /// `tokio::io::BufWriter` → `tokio::fs::File`, so **no Tokio worker is ever
 /// blocked** by disk I/O or compression.
 pub struct ZipService {
-    file_service: Arc<dyn FileRetrievalUseCase>,
-    folder_service: Arc<dyn FolderUseCase>,
+    file_service: Arc<FileRetrievalService>,
+    folder_service: Arc<FolderService>,
 }
 
 impl ZipService {
     /// Creates a new instance of the ZIP service
     pub fn new(
-        file_service: Arc<dyn FileRetrievalUseCase>,
-        folder_service: Arc<dyn FolderUseCase>,
+        file_service: Arc<FileRetrievalService>,
+        folder_service: Arc<FolderService>,
     ) -> Self {
         Self {
             file_service,
@@ -239,7 +240,6 @@ impl ZipService {
 
 // ─── Port implementation ─────────────────────────────────────────────────────
 
-#[async_trait]
 impl ZipPort for ZipService {
     async fn create_folder_zip(
         &self,

src/interfaces/api/handlers/admin_handler.rs

@@ -14,6 +14,7 @@ use crate::application::dtos::settings_dto::{
 use crate::common::di::AppState;
 use crate::interfaces::errors::AppError;
 use std::sync::Arc;
+use crate::application::ports::auth_ports::TokenServicePort;
 
 /// Admin API routes — all require admin role.
 pub fn admin_routes() -> Router<Arc<AppState>> {

src/interfaces/api/handlers/caldav_handler.rs

@@ -35,6 +35,7 @@ use crate::application::ports::calendar_ports::CalendarUseCase;
 use crate::common::di::AppState;
 use crate::interfaces::errors::AppError;
 use crate::interfaces::middleware::auth::CurrentUser;
+use crate::application::services::calendar_service::CalendarService;
 
 const HEADER_DAV: HeaderName = HeaderName::from_static("dav");
 
@@ -127,7 +128,7 @@ fn extract_user(req: &Request<Body>) -> Result<CurrentUser, AppError> {
         .ok_or_else(|| AppError::unauthorized("Authentication required"))
 }
 
-fn get_calendar_service(state: &AppState) -> Result<&Arc<dyn CalendarUseCase>, AppError> {
+fn get_calendar_service(state: &AppState) -> Result<&Arc<CalendarService>, AppError> {
     state.calendar_use_case.as_ref().ok_or_else(|| {
         AppError::new(
             StatusCode::NOT_IMPLEMENTED,

src/interfaces/api/handlers/carddav_handler.rs

@@ -35,6 +35,7 @@ use crate::application::ports::carddav_ports::{AddressBookUseCase, ContactUseCas
 use crate::common::di::AppState;
 use crate::interfaces::errors::AppError;
 use crate::interfaces::middleware::auth::CurrentUser;
+use crate::infrastructure::adapters::contact_storage_adapter::ContactStorageAdapter;
 
 const HEADER_DAV: HeaderName = HeaderName::from_static("dav");
 
@@ -115,7 +116,7 @@ fn extract_user(req: &Request<Body>) -> Result<CurrentUser, AppError> {
         .ok_or_else(|| AppError::unauthorized("Authentication required"))
 }
 
-fn get_addressbook_service(state: &AppState) -> Result<&Arc<dyn AddressBookUseCase>, AppError> {
+fn get_addressbook_service(state: &AppState) -> Result<&Arc<ContactStorageAdapter>, AppError> {
     state.addressbook_use_case.as_ref().ok_or_else(|| {
         AppError::new(
             StatusCode::NOT_IMPLEMENTED,
@@ -125,7 +126,7 @@ fn get_addressbook_service(state: &AppState) -> Result<&Arc<dyn AddressBookUseCa
     })
 }
 
-fn get_contact_service(state: &AppState) -> Result<&Arc<dyn ContactUseCase>, AppError> {
+fn get_contact_service(state: &AppState) -> Result<&Arc<ContactStorageAdapter>, AppError> {
     state.contact_use_case.as_ref().ok_or_else(|| {
         AppError::new(
             StatusCode::NOT_IMPLEMENTED,

src/interfaces/api/handlers/chunked_upload_handler.rs

@@ -21,6 +21,9 @@ use crate::application::ports::chunked_upload_ports::DEFAULT_CHUNK_SIZE;
 use crate::common::di::AppState;
 use crate::domain::errors::ErrorKind;
 use crate::interfaces::middleware::auth::AuthUser;
+use crate::application::ports::chunked_upload_ports::ChunkedUploadPort;
+use crate::application::ports::file_ports::FileUploadUseCase;
+use crate::application::ports::storage_ports::StorageUsagePort;
 
 /// Request body for creating an upload session
 #[derive(Debug, Deserialize)]

src/interfaces/api/handlers/favorites_handler.rs

@@ -10,6 +10,7 @@ use tracing::{error, info};
 
 use crate::application::ports::favorites_ports::FavoritesUseCase;
 use crate::interfaces::middleware::auth::AuthUser;
+use crate::application::services::favorites_service::FavoritesService;
 
 /// Single item in a batch-add-favorites request.
 #[derive(Debug, Deserialize)]
@@ -26,7 +27,7 @@ pub struct BatchFavoritesRequest {
 
 /// Handler for favorite-related API endpoints
 pub async fn get_favorites(
-    State(favorites_service): State<Arc<dyn FavoritesUseCase>>,
+    State(favorites_service): State<Arc<FavoritesService>>,
     auth_user: AuthUser,
 ) -> impl IntoResponse {
     let user_id = &auth_user.id;
@@ -51,7 +52,7 @@ pub async fn get_favorites(
 
 /// Add an item to user's favorites
 pub async fn add_favorite(
-    State(favorites_service): State<Arc<dyn FavoritesUseCase>>,
+    State(favorites_service): State<Arc<FavoritesService>>,
     auth_user: AuthUser,
     Path((item_type, item_id)): Path<(String, String)>,
 ) -> impl IntoResponse {
@@ -94,7 +95,7 @@ pub async fn add_favorite(
 
 /// Remove an item from user's favorites
 pub async fn remove_favorite(
-    State(favorites_service): State<Arc<dyn FavoritesUseCase>>,
+    State(favorites_service): State<Arc<FavoritesService>>,
     auth_user: AuthUser,
     Path((item_type, item_id)): Path<(String, String)>,
 ) -> impl IntoResponse {
@@ -138,7 +139,7 @@ pub async fn remove_favorite(
 /// Add multiple items to favourites in a single transaction.
 /// POST /api/favorites/batch
 pub async fn batch_add_favorites(
-    State(favorites_service): State<Arc<dyn FavoritesUseCase>>,
+    State(favorites_service): State<Arc<FavoritesService>>,
     auth_user: AuthUser,
     Json(body): Json<BatchFavoritesRequest>,
 ) -> impl IntoResponse {

src/interfaces/api/handlers/file_handler.rs

@@ -14,6 +14,9 @@ use crate::application::ports::file_ports::OptimizedFileContent;
 use crate::common::di::AppState;
 use crate::interfaces::middleware::auth::{AuthUser, OptionalUserId};
 use std::sync::Arc;
+use crate::application::ports::file_ports::{FileManagementUseCase, FileRetrievalUseCase, FileUploadUseCase};
+use crate::application::ports::storage_ports::StorageUsagePort;
+use crate::application::ports::thumbnail_ports::ThumbnailPort;
 
 /**
  * Type aliases for dependency injection state.
@@ -306,7 +309,7 @@ impl FileHandler {
         let file_path = storage_root.join(&file.path);
 
         match thumbnail_service
-            .get_thumbnail(&id, thumb_size, &file_path)
+            .get_thumbnail(&id, thumb_size.into(), &file_path)
             .await
         {
             Ok(data) => {

src/interfaces/api/handlers/folder_handler.rs

@@ -18,6 +18,8 @@ use crate::application::services::folder_service::FolderService;
 use crate::common::di::AppState as GlobalAppState;
 use crate::common::errors::ErrorKind;
 use crate::interfaces::middleware::auth::AuthUser;
+use crate::application::ports::file_ports::FileRetrievalUseCase;
+use crate::application::ports::trash_ports::TrashUseCase;
 
 type AppState = Arc<FolderService>;
 
@@ -423,7 +425,17 @@ impl FolderHandler {
                 tracing::info!("Preparing ZIP for folder: {} ({})", folder.name, id);
 
                 // Use ZIP service from DI container
-                let zip_service = &state.core.zip_service;
+                let zip_service = match &state.core.zip_service {
+                    Some(svc) => svc,
+                    None => {
+                        tracing::error!("ZipService not initialized");
+                        return (
+                            StatusCode::INTERNAL_SERVER_ERROR,
+                            Json(serde_json::json!({ "error": "ZipService not initialized" })),
+                        )
+                            .into_response();
+                    }
+                };
 
                 // Create the ZIP archive (written to a temp file, O(1) RAM)
                 match zip_service.create_folder_zip(&id, &folder.name).await {

src/interfaces/api/handlers/recent_handler.rs

@@ -10,6 +10,7 @@ use tracing::{error, info};
 
 use crate::application::ports::recent_ports::RecentItemsUseCase;
 use crate::interfaces::middleware::auth::AuthUser;
+use crate::application::services::recent_service::RecentService;
 
 /// Query parameters for getting recent items
 #[derive(Deserialize)]
@@ -20,7 +21,7 @@ pub struct GetRecentParams {
 
 /// Get user's recent items
 pub async fn get_recent_items(
-    State(recent_service): State<Arc<dyn RecentItemsUseCase>>,
+    State(recent_service): State<Arc<RecentService>>,
     auth_user: AuthUser,
     Query(params): Query<GetRecentParams>,
 ) -> impl IntoResponse {
@@ -46,7 +47,7 @@ pub async fn get_recent_items(
 
 /// Record access to an item
 pub async fn record_item_access(
-    State(recent_service): State<Arc<dyn RecentItemsUseCase>>,
+    State(recent_service): State<Arc<RecentService>>,
     auth_user: AuthUser,
     Path((item_type, item_id)): Path<(String, String)>,
 ) -> impl IntoResponse {
@@ -92,7 +93,7 @@ pub async fn record_item_access(
 
 /// Remove an item from recents
 pub async fn remove_from_recent(
-    State(recent_service): State<Arc<dyn RecentItemsUseCase>>,
+    State(recent_service): State<Arc<RecentService>>,
     auth_user: AuthUser,
     Path((item_type, item_id)): Path<(String, String)>,
 ) -> impl IntoResponse {
@@ -138,7 +139,7 @@ pub async fn remove_from_recent(
 
 /// Clear all recent items
 pub async fn clear_recent_items(
-    State(recent_service): State<Arc<dyn RecentItemsUseCase>>,
+    State(recent_service): State<Arc<RecentService>>,
     auth_user: AuthUser,
 ) -> impl IntoResponse {
     let user_id = &auth_user.id;

src/interfaces/api/handlers/search_handler.rs

@@ -10,6 +10,7 @@ use crate::application::dtos::search_dto::SearchCriteriaDto;
 use crate::common::di::AppState;
 use crate::interfaces::middleware::auth::AuthUser;
 use std::sync::Arc;
+use crate::application::ports::inbound::SearchUseCase;
 
 /**
  * Handler for search operations through the API.

src/interfaces/api/handlers/share_handler.rs

@@ -18,6 +18,7 @@ use crate::{
     domain::entities::share::ShareItemType,
     interfaces::middleware::auth::OptionalAuthUser,
 };
+use crate::application::services::share_service::ShareService;
 
 #[derive(Debug, Deserialize)]
 pub struct GetSharesQuery {
@@ -34,7 +35,7 @@ pub struct VerifyPasswordRequest {
 
 /// Create a new shared link
 pub async fn create_shared_link(
-    State(share_use_case): State<Arc<dyn ShareUseCase>>,
+    State(share_use_case): State<Arc<ShareService>>,
     auth_user: OptionalAuthUser,
     Json(dto): Json<CreateShareDto>,
 ) -> impl IntoResponse {
@@ -57,7 +58,7 @@ pub async fn create_shared_link(
 
 /// Get information about a specific shared link by ID
 pub async fn get_shared_link(
-    State(share_use_case): State<Arc<dyn ShareUseCase>>,
+    State(share_use_case): State<Arc<ShareService>>,
     Path(id): Path<String>,
 ) -> impl IntoResponse {
     match share_use_case.get_shared_link(&id).await {
@@ -75,7 +76,7 @@ pub async fn get_shared_link(
 /// Get all shared links created by the current user.
 /// Supports optional filtering by item_id + item_type query params.
 pub async fn get_user_shares(
-    State(share_use_case): State<Arc<dyn ShareUseCase>>,
+    State(share_use_case): State<Arc<ShareService>>,
     auth_user: OptionalAuthUser,
     Query(query): Query<GetSharesQuery>,
 ) -> impl IntoResponse {
@@ -128,7 +129,7 @@ pub async fn get_user_shares(
 
 /// Update a shared link's properties
 pub async fn update_shared_link(
-    State(share_use_case): State<Arc<dyn ShareUseCase>>,
+    State(share_use_case): State<Arc<ShareService>>,
     Path(id): Path<String>,
     Json(dto): Json<UpdateShareDto>,
 ) -> impl IntoResponse {
@@ -148,7 +149,7 @@ pub async fn update_shared_link(
 
 /// Delete a shared link
 pub async fn delete_shared_link(
-    State(share_use_case): State<Arc<dyn ShareUseCase>>,
+    State(share_use_case): State<Arc<ShareService>>,
     Path(id): Path<String>,
 ) -> impl IntoResponse {
     match share_use_case.delete_shared_link(&id).await {
@@ -166,7 +167,7 @@ pub async fn delete_shared_link(
 
 /// Access a shared item via its token
 pub async fn access_shared_item(
-    State(share_use_case): State<Arc<dyn ShareUseCase>>,
+    State(share_use_case): State<Arc<ShareService>>,
     Path(token): Path<String>,
 ) -> impl IntoResponse {
     // Register the access
@@ -204,7 +205,7 @@ pub async fn access_shared_item(
 
 /// Verify password for a password-protected shared item
 pub async fn verify_shared_item_password(
-    State(share_use_case): State<Arc<dyn ShareUseCase>>,
+    State(share_use_case): State<Arc<ShareService>>,
     Path(token): Path<String>,
     Json(req): Json<VerifyPasswordRequest>,
 ) -> impl IntoResponse {

src/interfaces/api/handlers/trash_handler.rs

@@ -4,7 +4,7 @@ use axum::http::StatusCode;
 use serde_json::json;
 use tracing::{debug, error, instrument, warn};
 
-// use crate::application::ports::trash_ports::TrashUseCase;
+use crate::application::ports::trash_ports::TrashUseCase;
 use crate::common::di::AppState;
 use crate::interfaces::middleware::auth::{AuthUser, OptionalAuthUser};
 use std::sync::Arc;

src/interfaces/api/handlers/webdav_handler.rs

@@ -28,8 +28,11 @@ use crate::common::di::AppState;
 use crate::infrastructure::services::path_resolver_service::ResolvedResource;
 use crate::interfaces::errors::AppError;
 use crate::interfaces::middleware::auth::CurrentUser;
+use crate::application::services::file_retrieval_service::FileRetrievalService;
+use crate::application::services::folder_service::FolderService;
 use percent_encoding::{AsciiSet, NON_ALPHANUMERIC, percent_decode_str, utf8_percent_encode};
 use std::sync::Arc;
+use crate::application::ports::file_ports::{FileManagementUseCase, FileUploadUseCase};
 
 /// Characters that MUST NOT be percent-encoded inside a URI path segment.
 /// RFC 3986 §3.3 pchar = unreserved / pct-encoded / sub-delims / ":" / "@"
@@ -394,8 +397,8 @@ async fn build_streaming_propfind_response(
     depth: &str,
     base_href: &str,
     propfind_request: PropFindRequest,
-    folder_service: std::sync::Arc<dyn FolderUseCase>,
-    file_retrieval_service: std::sync::Arc<dyn FileRetrievalUseCase>,
+    folder_service: std::sync::Arc<FolderService>,
+    file_retrieval_service: std::sync::Arc<FileRetrievalService>,
 ) -> Result<Response<Body>, AppError> {
     let depth = depth.to_string();
     let base_href = base_href.to_string();

src/interfaces/api/handlers/wopi_handler.rs

@@ -23,6 +23,7 @@ use std::sync::Arc;
 use crate::application::services::wopi_lock_service::WopiLockService;
 use crate::application::services::wopi_token_service::WopiTokenService;
 use crate::infrastructure::services::wopi_discovery_service::WopiDiscoveryService;
+use crate::application::ports::file_ports::{FileRetrievalUseCase, FileUploadUseCase};
 
 /// Shared state for WOPI handlers.
 #[derive(Clone)]

src/interfaces/api/routes.rs

@@ -8,6 +8,7 @@ use axum::{
 use serde_json::json;
 use std::sync::Arc;
 use tower_http::{compression::CompressionLayer, trace::TraceLayer};
+use crate::application::services::batch_operations::BatchOperationService;
 
 /// Returns the application version from Cargo.toml (compile-time constant)
 async fn get_version() -> AxumJson<serde_json::Value> {
@@ -17,7 +18,6 @@ async fn get_version() -> AxumJson<serde_json::Value> {
     }))
 }
 
-use crate::application::services::batch_operations::BatchOperationService;
 
 use crate::interfaces::api::handlers::admin_handler;
 use crate::interfaces::api::handlers::batch_handler::{self, BatchHandlerState};