adding user authentication

src/domain/repositories/file_repository.rs

@@ -1,6 +1,7 @@
 use async_trait::async_trait;
 use crate::domain::entities::file::File;
 use crate::domain::services::path_service::StoragePath;
+use crate::common::errors::DomainError;
 use futures::Stream;
 use bytes::Bytes;
 
@@ -23,9 +24,15 @@ pub enum FileRepositoryError {
     #[error("Mapping error: {0}")]
     MappingError(String),
     
+    #[error("ID Mapping error: {0}")]
+    IdMappingError(String),
+    
     #[error("Timeout error: {0}")]
     Timeout(String),
     
+    #[error("Domain error: {0}")]
+    DomainError(#[from] DomainError),
+    
     #[error("Other error: {0}")]
     Other(String),
 }

src/domain/repositories/folder_repository.rs

@@ -1,6 +1,7 @@
 use async_trait::async_trait;
 use crate::domain::entities::folder::Folder;
 use crate::domain::services::path_service::StoragePath;
+use crate::common::errors::DomainError;
 
 /// Error types for folder repository operations
 #[derive(Debug, thiserror::Error)]
@@ -24,6 +25,9 @@ pub enum FolderRepositoryError {
     #[error("Validation error: {0}")]
     ValidationError(String),
     
+    #[error("Domain error: {0}")]
+    DomainError(#[from] DomainError),
+    
     #[error("Other error: {0}")]
     Other(String),
 }

src/domain/repositories/mod.rs

@@ -1,3 +1,5 @@
 pub mod file_repository;
 pub mod folder_repository;
+pub mod user_repository;
+pub mod session_repository;
 

src/domain/repositories/session_repository.rs

@@ -0,0 +1,58 @@
+use async_trait::async_trait;
+use crate::domain::entities::session::Session;
+use crate::common::errors::DomainError;
+
+#[derive(Debug, thiserror::Error)]
+pub enum SessionRepositoryError {
+    #[error("Sesión no encontrada: {0}")]
+    NotFound(String),
+    
+    #[error("Error de base de datos: {0}")]
+    DatabaseError(String),
+    
+    #[error("Error de tiempo de espera: {0}")]
+    Timeout(String),
+}
+
+pub type SessionRepositoryResult<T> = Result<T, SessionRepositoryError>;
+
+// Conversión de SessionRepositoryError a DomainError
+impl From<SessionRepositoryError> for DomainError {
+    fn from(err: SessionRepositoryError) -> Self {
+        match err {
+            SessionRepositoryError::NotFound(msg) => {
+                DomainError::not_found("Session", msg)
+            },
+            SessionRepositoryError::DatabaseError(msg) => {
+                DomainError::internal_error("Database", msg)
+            },
+            SessionRepositoryError::Timeout(msg) => {
+                DomainError::timeout("Database", msg)
+            },
+        }
+    }
+}
+
+#[async_trait]
+pub trait SessionRepository: Send + Sync + 'static {
+    /// Crea una nueva sesión
+    async fn create_session(&self, session: Session) -> SessionRepositoryResult<Session>;
+    
+    /// Obtiene una sesión por ID
+    async fn get_session_by_id(&self, id: &str) -> SessionRepositoryResult<Session>;
+    
+    /// Obtiene una sesión por token de actualización
+    async fn get_session_by_refresh_token(&self, refresh_token: &str) -> SessionRepositoryResult<Session>;
+    
+    /// Obtiene todas las sesiones de un usuario
+    async fn get_sessions_by_user_id(&self, user_id: &str) -> SessionRepositoryResult<Vec<Session>>;
+    
+    /// Revoca una sesión específica
+    async fn revoke_session(&self, session_id: &str) -> SessionRepositoryResult<()>;
+    
+    /// Revoca todas las sesiones de un usuario
+    async fn revoke_all_user_sessions(&self, user_id: &str) -> SessionRepositoryResult<u64>;
+    
+    /// Elimina sesiones expiradas
+    async fn delete_expired_sessions(&self) -> SessionRepositoryResult<u64>;
+}

src/domain/repositories/user_repository.rs

@@ -0,0 +1,91 @@
+use async_trait::async_trait;
+use crate::domain::entities::user::{User, UserRole};
+use crate::common::errors::DomainError;
+
+#[derive(Debug, thiserror::Error)]
+pub enum UserRepositoryError {
+    #[error("Usuario no encontrado: {0}")]
+    NotFound(String),
+    
+    #[error("Usuario ya existe: {0}")]
+    AlreadyExists(String),
+    
+    #[error("Error de base de datos: {0}")]
+    DatabaseError(String),
+    
+    #[error("Error de validación: {0}")]
+    ValidationError(String),
+    
+    #[error("Error de tiempo de espera: {0}")]
+    Timeout(String),
+    
+    #[error("Operación no permitida: {0}")]
+    OperationNotAllowed(String),
+}
+
+pub type UserRepositoryResult<T> = Result<T, UserRepositoryError>;
+
+// Conversión de UserRepositoryError a DomainError
+impl From<UserRepositoryError> for DomainError {
+    fn from(err: UserRepositoryError) -> Self {
+        match err {
+            UserRepositoryError::NotFound(msg) => {
+                DomainError::not_found("User", msg)
+            },
+            UserRepositoryError::AlreadyExists(msg) => {
+                DomainError::already_exists("User", msg)
+            },
+            UserRepositoryError::DatabaseError(msg) => {
+                DomainError::internal_error("Database", msg)
+            },
+            UserRepositoryError::ValidationError(msg) => {
+                DomainError::validation_error("User", msg)
+            },
+            UserRepositoryError::Timeout(msg) => {
+                DomainError::timeout("Database", msg)
+            },
+            UserRepositoryError::OperationNotAllowed(msg) => {
+                DomainError::access_denied("User", msg)
+            },
+        }
+    }
+}
+
+#[async_trait]
+pub trait UserRepository: Send + Sync + 'static {
+    /// Crea un nuevo usuario
+    async fn create_user(&self, user: User) -> UserRepositoryResult<User>;
+    
+    /// Obtiene un usuario por ID
+    async fn get_user_by_id(&self, id: &str) -> UserRepositoryResult<User>;
+    
+    /// Obtiene un usuario por nombre de usuario
+    async fn get_user_by_username(&self, username: &str) -> UserRepositoryResult<User>;
+    
+    /// Obtiene un usuario por correo electrónico
+    async fn get_user_by_email(&self, email: &str) -> UserRepositoryResult<User>;
+    
+    /// Actualiza un usuario existente
+    async fn update_user(&self, user: User) -> UserRepositoryResult<User>;
+    
+    /// Actualiza solo el uso de almacenamiento de un usuario
+    async fn update_storage_usage(&self, user_id: &str, usage_bytes: i64) -> UserRepositoryResult<()>;
+    
+    /// Actualiza la fecha de último inicio de sesión
+    async fn update_last_login(&self, user_id: &str) -> UserRepositoryResult<()>;
+    
+    /// Lista usuarios con paginación
+    async fn list_users(&self, limit: i64, offset: i64) -> UserRepositoryResult<Vec<User>>;
+    
+    /// Activa o desactiva un usuario
+    async fn set_user_active_status(&self, user_id: &str, active: bool) -> UserRepositoryResult<()>;
+    
+    /// Cambia la contraseña de un usuario
+    async fn change_password(&self, user_id: &str, password_hash: &str) -> UserRepositoryResult<()>;
+    
+    /// Cambia el rol de un usuario
+    async fn change_role(&self, user_id: &str, role: UserRole) -> UserRepositoryResult<()>;
+    
+    /// Elimina un usuario
+    async fn delete_user(&self, user_id: &str) -> UserRepositoryResult<()>;
+}