postgress
This commit is contained in:
MythEclipse
@@ -0,0 +1,355 @@
|
||||
//! Dual-mode repository pattern implementation
|
||||
//! Provides both PostgreSQL and in-memory repository implementations
|
||||
//! with seamless switching between modes for testing and production
|
||||
|
||||
use std::sync::Arc;
|
||||
use async_trait::async_trait;
|
||||
use uuid::Uuid;
|
||||
use chrono::{DateTime, Utc};
|
||||
use thiserror::Error;
|
||||
use sea_orm::{DbErr, ActiveModelTrait, ModelTrait, EntityTrait, QueryFilter, ColumnTrait, PaginatorTrait, QuerySelect, ActiveValue::Set,};
|
||||
|
||||
use crate::postgres::{PostgresConnection, PostgresError};
|
||||
use imphnen_entities::seaorm::auth::users::{Entity as UsersEntity, Model as UserModel};
|
||||
use imphnen_entities::seaorm::auth::roles::{Entity as RolesEntity, Model as RoleModel};
|
||||
|
||||
/// Error types for dual-mode repository operations
|
||||
#[derive(Debug, Error)]
|
||||
pub enum PostgresRepositoryError {
|
||||
#[error("Database error: {0}")]
|
||||
DatabaseError(#[from] DbErr),
|
||||
|
||||
#[error("PostgreSQL connection error: {0}")]
|
||||
ConnectionError(#[from] PostgresError),
|
||||
|
||||
#[error("Entity not found: {0}")]
|
||||
NotFound(String),
|
||||
|
||||
#[error("Validation error: {0}")]
|
||||
ValidationError(String),
|
||||
|
||||
#[error("Conversion error: {0}")]
|
||||
ConversionError(String),
|
||||
|
||||
#[error("Repository operation failed: {0}")]
|
||||
OperationFailed(String),
|
||||
}
|
||||
|
||||
/// Repository trait for user operations
|
||||
#[async_trait]
|
||||
pub trait PostgresRepository {
|
||||
/// Find user by ID
|
||||
async fn find_user_by_id(&self, id: Uuid) -> Result<Option<UserModel>, PostgresRepositoryError>;
|
||||
|
||||
/// Find user by email
|
||||
async fn find_user_by_email(&self, email: &str) -> Result<Option<UserModel>, PostgresRepositoryError>;
|
||||
|
||||
/// Find user by username
|
||||
async fn find_user_by_username(&self, username: &str) -> Result<Option<UserModel>, PostgresRepositoryError>;
|
||||
|
||||
/// Create new user
|
||||
async fn create_user(&self, user: UserModel) -> Result<UserModel, PostgresRepositoryError>;
|
||||
|
||||
/// Update user
|
||||
async fn update_user(&self, id: Uuid, user: UserModel) -> Result<UserModel, PostgresRepositoryError>;
|
||||
|
||||
/// Delete user
|
||||
async fn delete_user(&self, id: Uuid) -> Result<(), PostgresRepositoryError>;
|
||||
|
||||
/// List all users with pagination
|
||||
async fn list_users(&self, offset: u64, limit: u64) -> Result<Vec<UserModel>, PostgresRepositoryError>;
|
||||
|
||||
/// Count total users
|
||||
async fn count_users(&self) -> Result<u64, PostgresRepositoryError>;
|
||||
|
||||
/// Find role by ID
|
||||
async fn find_role_by_id(&self, id: Uuid) -> Result<Option<RoleModel>, PostgresRepositoryError>;
|
||||
|
||||
/// Find role by name
|
||||
async fn find_role_by_name(&self, name: &str) -> Result<Option<RoleModel>, PostgresRepositoryError>;
|
||||
|
||||
/// Create new role
|
||||
async fn create_role(&self, role: RoleModel) -> Result<RoleModel, PostgresRepositoryError>;
|
||||
|
||||
/// Update role
|
||||
async fn update_role(&self, id: Uuid, role: RoleModel) -> Result<RoleModel, PostgresRepositoryError>;
|
||||
|
||||
/// Delete role
|
||||
async fn delete_role(&self, id: Uuid) -> Result<(), PostgresRepositoryError>;
|
||||
|
||||
/// List all roles
|
||||
async fn list_roles(&self) -> Result<Vec<RoleModel>, PostgresRepositoryError>;
|
||||
}
|
||||
|
||||
/// Default PostgreSQL repository implementation
|
||||
pub struct PostgresRepositoryDefaultImpl {
|
||||
connection: Arc<PostgresConnection>,
|
||||
}
|
||||
|
||||
impl PostgresRepositoryDefaultImpl {
|
||||
/// Create a new PostgreSQL repository instance
|
||||
pub fn new(connection: Arc<PostgresConnection>) -> Self {
|
||||
Self { connection }
|
||||
}
|
||||
|
||||
/// Get the underlying PostgreSQL connection
|
||||
pub fn connection(&self) -> &Arc<PostgresConnection> {
|
||||
&self.connection
|
||||
}
|
||||
}
|
||||
|
||||
#[async_trait]
|
||||
impl PostgresRepository for PostgresRepositoryDefaultImpl {
|
||||
async fn find_user_by_id(&self, id: Uuid) -> Result<Option<UserModel>, PostgresRepositoryError> {
|
||||
let user = UsersEntity::find_by_id(id)
|
||||
.one(&self.connection.conn)
|
||||
.await
|
||||
.map_err(PostgresRepositoryError::DatabaseError)?;
|
||||
|
||||
Ok(user)
|
||||
}
|
||||
|
||||
async fn find_user_by_email(&self, email: &str) -> Result<Option<UserModel>, PostgresRepositoryError> {
|
||||
let user = UsersEntity::find()
|
||||
.filter(imphnen_entities::seaorm::auth::users::Column::Email.eq(email))
|
||||
.one(&self.connection.conn)
|
||||
.await
|
||||
.map_err(PostgresRepositoryError::DatabaseError)?;
|
||||
|
||||
Ok(user)
|
||||
}
|
||||
|
||||
async fn find_user_by_username(&self, username: &str) -> Result<Option<UserModel>, PostgresRepositoryError> {
|
||||
let user = UsersEntity::find()
|
||||
.filter(imphnen_entities::seaorm::auth::users::Column::Username.eq(username))
|
||||
.one(&self.connection.conn)
|
||||
.await
|
||||
.map_err(PostgresRepositoryError::DatabaseError)?;
|
||||
|
||||
Ok(user)
|
||||
}
|
||||
|
||||
async fn create_user(&self, user: UserModel) -> Result<UserModel, PostgresRepositoryError> {
|
||||
let active_model = imphnen_entities::seaorm::auth::users::ActiveModel {
|
||||
id: Set(user.id),
|
||||
email: Set(user.email),
|
||||
password_hash: Set(user.password_hash),
|
||||
username: Set(user.username),
|
||||
first_name: Set(user.first_name),
|
||||
last_name: Set(user.last_name),
|
||||
avatar_url: Set(user.avatar_url),
|
||||
is_verified: Set(user.is_verified),
|
||||
is_active: Set(user.is_active),
|
||||
metadata: Set(user.metadata),
|
||||
created_at: Set(user.created_at),
|
||||
updated_at: Set(user.updated_at),
|
||||
deleted_at: Set(user.deleted_at), // Use user.deleted_at
|
||||
role_id: Set(user.role_id),
|
||||
};
|
||||
|
||||
let created_user = active_model.insert(&self.connection.conn).await.map_err(PostgresRepositoryError::DatabaseError)?;
|
||||
Ok(created_user)
|
||||
}
|
||||
|
||||
async fn update_user(&self, id: Uuid, user: UserModel) -> Result<UserModel, PostgresRepositoryError> {
|
||||
let existing_user = self.find_user_by_id(id).await?
|
||||
.ok_or_else(|| PostgresRepositoryError::NotFound(format!("User with id {id} not found")))?;
|
||||
|
||||
let mut active_model: imphnen_entities::seaorm::auth::users::ActiveModel = existing_user.into();
|
||||
|
||||
// Update fields
|
||||
active_model.email = Set(user.email);
|
||||
active_model.password_hash = Set(user.password_hash);
|
||||
active_model.username = Set(user.username);
|
||||
active_model.first_name = Set(user.first_name);
|
||||
active_model.last_name = Set(user.last_name);
|
||||
active_model.avatar_url = Set(user.avatar_url);
|
||||
active_model.is_verified = Set(user.is_verified);
|
||||
active_model.is_active = Set(user.is_active);
|
||||
active_model.metadata = Set(user.metadata);
|
||||
active_model.updated_at = Set(user.updated_at);
|
||||
active_model.deleted_at = Set(user.deleted_at);
|
||||
active_model.role_id = Set(user.role_id); // Update role_id
|
||||
|
||||
let result = active_model
|
||||
.update(&self.connection.conn)
|
||||
.await
|
||||
.map_err(PostgresRepositoryError::DatabaseError)?;
|
||||
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
async fn delete_user(&self, id: Uuid) -> Result<(), PostgresRepositoryError> {
|
||||
let user = self.find_user_by_id(id).await?
|
||||
.ok_or_else(|| PostgresRepositoryError::NotFound(format!("User with id {id} not found")))?;
|
||||
|
||||
user.delete(&self.connection.conn)
|
||||
.await
|
||||
.map_err(PostgresRepositoryError::DatabaseError)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn list_users(&self, offset: u64, limit: u64) -> Result<Vec<UserModel>, PostgresRepositoryError> {
|
||||
let users = UsersEntity::find()
|
||||
.offset(offset)
|
||||
.limit(limit)
|
||||
.all(&self.connection.conn)
|
||||
.await
|
||||
.map_err(PostgresRepositoryError::DatabaseError)?;
|
||||
|
||||
Ok(users)
|
||||
}
|
||||
|
||||
async fn count_users(&self) -> Result<u64, PostgresRepositoryError> {
|
||||
let count = UsersEntity::find()
|
||||
.count(&self.connection.conn)
|
||||
.await
|
||||
.map_err(PostgresRepositoryError::DatabaseError)?;
|
||||
|
||||
Ok(count)
|
||||
}
|
||||
|
||||
async fn find_role_by_id(&self, id: Uuid) -> Result<Option<RoleModel>, PostgresRepositoryError> {
|
||||
let role = RolesEntity::find_by_id(id)
|
||||
.one(&self.connection.conn)
|
||||
.await
|
||||
.map_err(PostgresRepositoryError::DatabaseError)?;
|
||||
|
||||
Ok(role)
|
||||
}
|
||||
|
||||
async fn find_role_by_name(&self, name: &str) -> Result<Option<RoleModel>, PostgresRepositoryError> {
|
||||
let role = RolesEntity::find()
|
||||
.filter(imphnen_entities::seaorm::auth::roles::Column::Name.eq(name))
|
||||
.one(&self.connection.conn)
|
||||
.await
|
||||
.map_err(PostgresRepositoryError::DatabaseError)?;
|
||||
|
||||
Ok(role)
|
||||
}
|
||||
|
||||
async fn create_role(&self, role: RoleModel) -> Result<RoleModel, PostgresRepositoryError> {
|
||||
let active_model = imphnen_entities::seaorm::auth::roles::ActiveModel {
|
||||
id: Set(role.id),
|
||||
name: Set(role.name),
|
||||
description: Set(role.description),
|
||||
permissions: Set(role.permissions),
|
||||
is_system_role: Set(role.is_system_role),
|
||||
is_default: Set(role.is_default),
|
||||
created_at: Set(role.created_at),
|
||||
updated_at: Set(role.updated_at),
|
||||
deleted_at: Set(role.deleted_at),
|
||||
};
|
||||
|
||||
let result = active_model
|
||||
.insert(&self.connection.conn)
|
||||
.await
|
||||
.map_err(PostgresRepositoryError::DatabaseError)?;
|
||||
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
async fn update_role(&self, id: Uuid, role: RoleModel) -> Result<RoleModel, PostgresRepositoryError> {
|
||||
let existing_role = self.find_role_by_id(id).await?
|
||||
.ok_or_else(|| PostgresRepositoryError::NotFound(format!("Role with id {id} not found")))?;
|
||||
|
||||
let mut active_model: imphnen_entities::seaorm::auth::roles::ActiveModel = existing_role.into();
|
||||
|
||||
active_model.name = Set(role.name);
|
||||
active_model.description = Set(role.description);
|
||||
active_model.permissions = Set(role.permissions);
|
||||
active_model.is_system_role = Set(role.is_system_role);
|
||||
active_model.is_default = Set(role.is_default);
|
||||
active_model.updated_at = Set(role.updated_at);
|
||||
active_model.deleted_at = Set(role.deleted_at);
|
||||
|
||||
let result = active_model
|
||||
.update(&self.connection.conn)
|
||||
.await
|
||||
.map_err(PostgresRepositoryError::DatabaseError)?;
|
||||
|
||||
Ok(result)
|
||||
}
|
||||
|
||||
async fn delete_role(&self, id: Uuid) -> Result<(), PostgresRepositoryError> {
|
||||
let role = self.find_role_by_id(id).await?
|
||||
.ok_or_else(|| PostgresRepositoryError::NotFound(format!("Role with id {id} not found")))?;
|
||||
|
||||
role.delete(&self.connection.conn)
|
||||
.await
|
||||
.map_err(PostgresRepositoryError::DatabaseError)?;
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
async fn list_roles(&self) -> Result<Vec<RoleModel>, PostgresRepositoryError> {
|
||||
let roles = RolesEntity::find()
|
||||
.all(&self.connection.conn)
|
||||
.await
|
||||
.map_err(PostgresRepositoryError::DatabaseError)?;
|
||||
|
||||
Ok(roles)
|
||||
}
|
||||
}
|
||||
|
||||
/// Conversion utilities for data transformation between different formats
|
||||
pub mod conversion_utils {
|
||||
use super::*;
|
||||
use serde_json::Value;
|
||||
|
||||
/// Convert JSON value to PostgreSQL-compatible format
|
||||
pub fn json_to_pg_json(json: Value) -> Result<serde_json::Value, PostgresRepositoryError> {
|
||||
Ok(json)
|
||||
}
|
||||
|
||||
/// Convert PostgreSQL JSON to standard JSON value
|
||||
pub fn pg_json_to_json(pg_json: serde_json::Value) -> Result<Value, PostgresRepositoryError> {
|
||||
Ok(pg_json)
|
||||
}
|
||||
|
||||
/// Convert string to PostgreSQL UUID format
|
||||
pub fn string_to_uuid(uuid_str: &str) -> Result<Uuid, PostgresRepositoryError> {
|
||||
Uuid::parse_str(uuid_str)
|
||||
.map_err(|e| PostgresRepositoryError::ConversionError(format!("Invalid UUID: {e}")))
|
||||
}
|
||||
|
||||
/// Convert DateTime to PostgreSQL timestamp format
|
||||
pub fn datetime_to_pg_timestamp(dt: DateTime<Utc>) -> String {
|
||||
dt.format("%Y-%m-%d %H:%M:%S%.3f").to_string()
|
||||
}
|
||||
|
||||
/// Convert PostgreSQL timestamp string to DateTime
|
||||
pub fn pg_timestamp_to_datetime(pg_timestamp: &str) -> Result<DateTime<Utc>, PostgresRepositoryError> {
|
||||
DateTime::parse_from_rfc3339(pg_timestamp)
|
||||
.map(|dt| dt.with_timezone(&Utc))
|
||||
.map_err(|e| PostgresRepositoryError::ConversionError(format!("Invalid timestamp: {e}")))
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn test_conversion_utils() {
|
||||
// Test UUID conversion
|
||||
let uuid_str = "550e8400-e29b-41d4-a716-446655440000";
|
||||
let uuid = conversion_utils::string_to_uuid(uuid_str).unwrap();
|
||||
assert_eq!(uuid.to_string(), uuid_str);
|
||||
|
||||
// Test timestamp conversion
|
||||
let now = Utc::now();
|
||||
let pg_timestamp = conversion_utils::datetime_to_pg_timestamp(now);
|
||||
assert!(!pg_timestamp.is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_postgres_repository_error() {
|
||||
let error = PostgresRepositoryError::NotFound("Test error".to_string());
|
||||
assert_eq!(error.to_string(), "Entity not found: Test error");
|
||||
|
||||
let error = PostgresRepositoryError::ValidationError("Invalid input".to_string());
|
||||
assert_eq!(error.to_string(), "Validation error: Invalid input");
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user