refactor: migrate to clean architecture with trait-based DI (v0.2.0)

Complete architectural overhaul across all 12 crates:

- Replace validator crate with zod-rs for all DTO validation
- Replace manual pagination with paginator-rs/paginator-sea-orm
- Migrate all modules (iam, cms, gacha, dimentorin) to clean architecture:
  domain → application → infrastructure layers
- Introduce trait-based DI (Arc<dyn Trait>) at every layer for repositories and services
- Delete all v1/ legacy SurrealDB-era code across every crate
- Replace opaque response helpers with typed IntoResponse structs (ApiSuccess, ApiCreated, ApiPaginated, ApiMessage)
- Remove dual_mode_repository, migration_validation_errors, validator.rs dead code
- Zero cargo clippy warnings; release build clean

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

imphnen-cms/src/testimonials/infrastructure/persistence/postgres_testimonial_repository.rs

@@ -0,0 +1,159 @@
+use std::sync::Arc;
+use async_trait::async_trait;
+use sea_orm::prelude::*;
+use sea_orm::{ActiveValue, QueryOrder, PaginatorTrait};
+use paginator_rs::{PaginationParams, SortDirection};
+use paginator_utils::{PaginatorResponse, PaginatorResponseMeta};
+use uuid::Uuid;
+use imphnen_utils::AppError;
+use imphnen_entities::seaorm::common::testimonials::{
+    Entity as TestimonialsEntity, Column as TestimonialsColumn, ActiveModel as TestimonialsActiveModel,
+};
+use imphnen_entities::seaorm::auth::users::Entity as UsersEntity;
+use crate::testimonials::domain::{testimonial::TestimonialEntity, repository::TestimonialRepository};
+
+pub struct PostgresTestimonialRepository {
+    db: Arc<DatabaseConnection>,
+}
+
+impl PostgresTestimonialRepository {
+    pub fn new(db: DatabaseConnection) -> Self {
+        Self { db: Arc::new(db) }
+    }
+}
+
+#[async_trait]
+impl TestimonialRepository for PostgresTestimonialRepository {
+    async fn find_all(&self, params: PaginationParams) -> Result<PaginatorResponse<TestimonialEntity>, AppError> {
+        let page = params.page.max(1);
+        let per_page = params.per_page.clamp(1, 100);
+
+        let mut query = TestimonialsEntity::find()
+            .filter(TestimonialsColumn::IsDeleted.eq(false))
+            .find_also_related(UsersEntity);
+
+        query = match params.sort_by.as_deref() {
+            Some("updated_at") => match params.sort_direction {
+                Some(SortDirection::Asc) => query.order_by_asc(TestimonialsColumn::UpdatedAt),
+                _ => query.order_by_desc(TestimonialsColumn::UpdatedAt),
+            },
+            _ => match params.sort_direction {
+                Some(SortDirection::Asc) => query.order_by_asc(TestimonialsColumn::CreatedAt),
+                _ => query.order_by_desc(TestimonialsColumn::CreatedAt),
+            },
+        };
+
+        let paginator = query.paginate(self.db.as_ref(), per_page as u64);
+        let total = paginator.num_items().await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+        let rows = paginator.fetch_page((page - 1) as u64).await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+
+        let data: Vec<TestimonialEntity> = rows.into_iter()
+            .filter_map(|(t, u)| {
+                u.map(|user| TestimonialEntity {
+                    id: t.id,
+                    user_id: t.user_id,
+                    user_fullname: format!(
+                        "{} {}",
+                        user.first_name.as_deref().unwrap_or(""),
+                        user.last_name.as_deref().unwrap_or("")
+                    ).trim().to_string(),
+                    role: t.role,
+                    content: t.content,
+                    is_deleted: t.is_deleted,
+                    created_at: t.created_at.to_rfc3339(),
+                    updated_at: t.updated_at.to_rfc3339(),
+                })
+            })
+            .collect();
+
+        let meta = PaginatorResponseMeta::new(page, per_page, total as u32);
+        Ok(PaginatorResponse { data, meta })
+    }
+
+    async fn find_by_id(&self, id: Uuid) -> Result<TestimonialEntity, AppError> {
+        let (testimonial, user) = TestimonialsEntity::find_by_id(id)
+            .filter(TestimonialsColumn::IsDeleted.eq(false))
+            .find_also_related(UsersEntity)
+            .one(self.db.as_ref())
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?
+            .ok_or_else(|| AppError::NotFoundError("Testimonial not found".to_string()))?;
+
+        let user = user.ok_or_else(|| AppError::NotFoundError("User not found for testimonial".to_string()))?;
+
+        Ok(TestimonialEntity {
+            id: testimonial.id,
+            user_id: testimonial.user_id,
+            user_fullname: format!(
+                "{} {}",
+                user.first_name.as_deref().unwrap_or(""),
+                user.last_name.as_deref().unwrap_or("")
+            ).trim().to_string(),
+            role: testimonial.role,
+            content: testimonial.content,
+            is_deleted: testimonial.is_deleted,
+            created_at: testimonial.created_at.to_rfc3339(),
+            updated_at: testimonial.updated_at.to_rfc3339(),
+        })
+    }
+
+    async fn create(&self, entity: TestimonialEntity) -> Result<TestimonialEntity, AppError> {
+        let active_model = TestimonialsActiveModel {
+            id: ActiveValue::Set(entity.id),
+            user_id: ActiveValue::Set(entity.user_id),
+            role: ActiveValue::Set(entity.role.clone()),
+            content: ActiveValue::Set(entity.content.clone()),
+            is_deleted: ActiveValue::Set(false),
+            created_at: ActiveValue::Set(chrono::Utc::now()),
+            updated_at: ActiveValue::Set(chrono::Utc::now()),
+        };
+
+        let inserted = active_model.insert(self.db.as_ref()).await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+
+        Ok(TestimonialEntity {
+            id: inserted.id,
+            user_id: inserted.user_id,
+            user_fullname: entity.user_fullname,
+            role: inserted.role,
+            content: inserted.content,
+            is_deleted: inserted.is_deleted,
+            created_at: inserted.created_at.to_rfc3339(),
+            updated_at: inserted.updated_at.to_rfc3339(),
+        })
+    }
+
+    async fn update(&self, entity: TestimonialEntity) -> Result<(), AppError> {
+        let mut active_model: TestimonialsActiveModel = TestimonialsEntity::find_by_id(entity.id)
+            .one(self.db.as_ref())
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?
+            .ok_or_else(|| AppError::NotFoundError("Testimonial not found".to_string()))?
+            .into();
+
+        active_model.role = ActiveValue::Set(entity.role);
+        active_model.content = ActiveValue::Set(entity.content);
+        active_model.updated_at = ActiveValue::Set(chrono::Utc::now());
+
+        active_model.update(self.db.as_ref()).await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+        Ok(())
+    }
+
+    async fn delete(&self, id: Uuid) -> Result<(), AppError> {
+        let mut active_model: TestimonialsActiveModel = TestimonialsEntity::find_by_id(id)
+            .one(self.db.as_ref())
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?
+            .ok_or_else(|| AppError::NotFoundError("Testimonial not found".to_string()))?
+            .into();
+
+        active_model.is_deleted = ActiveValue::Set(true);
+        active_model.updated_at = ActiveValue::Set(chrono::Utc::now());
+        active_model.update(self.db.as_ref()).await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+        Ok(())
+    }
+}