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/events/application/event_service.rs

@@ -0,0 +1,40 @@
+use std::sync::Arc;
+use async_trait::async_trait;
+use paginator_rs::PaginationParams;
+use paginator_utils::PaginatorResponse;
+use uuid::Uuid;
+use imphnen_utils::AppError;
+use crate::events::domain::{EventEntity, EventRepository, EventService};
+
+pub struct EventServiceImpl {
+    repo: Arc<dyn EventRepository>,
+}
+
+impl EventServiceImpl {
+    pub fn new(repo: Arc<dyn EventRepository>) -> Self {
+        Self { repo }
+    }
+}
+
+#[async_trait]
+impl EventService for EventServiceImpl {
+    async fn list(&self, params: PaginationParams) -> Result<PaginatorResponse<EventEntity>, AppError> {
+        self.repo.find_all(params).await
+    }
+
+    async fn get(&self, id: Uuid) -> Result<EventEntity, AppError> {
+        self.repo.find_by_id(id).await
+    }
+
+    async fn create(&self, entity: EventEntity) -> Result<(), AppError> {
+        self.repo.create(entity).await
+    }
+
+    async fn update(&self, entity: EventEntity) -> Result<(), AppError> {
+        self.repo.update(entity).await
+    }
+
+    async fn delete(&self, id: Uuid) -> Result<(), AppError> {
+        self.repo.delete(id).await
+    }
+}

imphnen-cms/src/events/application/mod.rs

@@ -0,0 +1,3 @@
+pub mod event_service;
+
+pub use event_service::EventServiceImpl;

imphnen-cms/src/events/domain/event.rs

@@ -0,0 +1,18 @@
+use chrono::{DateTime, Utc};
+use uuid::Uuid;
+
+#[derive(Clone, Debug)]
+pub struct EventEntity {
+    pub id: Uuid,
+    pub name: String,
+    pub description: String,
+    pub detail_link: String,
+    pub price: f64,
+    pub is_online: bool,
+    pub is_deleted: bool,
+    pub location: Option<String>,
+    pub start_date: DateTime<Utc>,
+    pub end_date: DateTime<Utc>,
+    pub created_at: DateTime<Utc>,
+    pub updated_at: DateTime<Utc>,
+}

imphnen-cms/src/events/domain/mod.rs

@@ -0,0 +1,7 @@
+pub mod event;
+pub mod repository;
+pub mod service;
+
+pub use event::EventEntity;
+pub use repository::EventRepository;
+pub use service::EventService;

imphnen-cms/src/events/domain/repository.rs

@@ -0,0 +1,15 @@
+use async_trait::async_trait;
+use paginator_rs::PaginationParams;
+use paginator_utils::PaginatorResponse;
+use uuid::Uuid;
+use imphnen_utils::AppError;
+use super::event::EventEntity;
+
+#[async_trait]
+pub trait EventRepository: Send + Sync {
+    async fn find_all(&self, params: PaginationParams) -> Result<PaginatorResponse<EventEntity>, AppError>;
+    async fn find_by_id(&self, id: Uuid) -> Result<EventEntity, AppError>;
+    async fn create(&self, entity: EventEntity) -> Result<(), AppError>;
+    async fn update(&self, entity: EventEntity) -> Result<(), AppError>;
+    async fn delete(&self, id: Uuid) -> Result<(), AppError>;
+}

imphnen-cms/src/events/domain/service.rs

@@ -0,0 +1,15 @@
+use async_trait::async_trait;
+use paginator_rs::PaginationParams;
+use paginator_utils::PaginatorResponse;
+use uuid::Uuid;
+use imphnen_utils::AppError;
+use super::event::EventEntity;
+
+#[async_trait]
+pub trait EventService: Send + Sync {
+    async fn list(&self, params: PaginationParams) -> Result<PaginatorResponse<EventEntity>, AppError>;
+    async fn get(&self, id: Uuid) -> Result<EventEntity, AppError>;
+    async fn create(&self, entity: EventEntity) -> Result<(), AppError>;
+    async fn update(&self, entity: EventEntity) -> Result<(), AppError>;
+    async fn delete(&self, id: Uuid) -> Result<(), AppError>;
+}

imphnen-cms/src/events/infrastructure/http/dto.rs

@@ -0,0 +1,131 @@
+use chrono::{DateTime, Utc};
+use imphnen_libs::ZodValidate;
+use serde::{Deserialize, Serialize};
+use utoipa::ToSchema;
+use uuid::Uuid;
+use crate::events::domain::event::EventEntity;
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct EventsCreateRequestDto {
+    pub name: String,
+    pub description: String,
+    pub detail_link: String,
+    pub price: f64,
+    #[schema(example = "2025-09-20T13:00:00Z", value_type = String)]
+    pub end_date: DateTime<Utc>,
+    #[schema(example = "2025-09-20T13:00:00Z", value_type = String)]
+    pub start_date: DateTime<Utc>,
+    pub location: Option<String>,
+    pub is_online: bool,
+}
+
+impl ZodValidate for EventsCreateRequestDto {
+    fn zod_validate(value: &serde_json::Value) -> Result<Self, String> {
+        serde_json::from_value(value.clone()).map_err(|e| e.to_string())
+    }
+}
+
+impl From<EventsCreateRequestDto> for EventEntity {
+    fn from(dto: EventsCreateRequestDto) -> Self {
+        EventEntity {
+            id: Uuid::new_v4(),
+            name: dto.name,
+            description: dto.description,
+            detail_link: dto.detail_link,
+            price: dto.price,
+            is_online: dto.is_online,
+            is_deleted: false,
+            location: dto.location,
+            start_date: dto.start_date,
+            end_date: dto.end_date,
+            created_at: chrono::Utc::now(),
+            updated_at: chrono::Utc::now(),
+        }
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct EventsUpdateRequestDto {
+    pub name: String,
+    #[schema(example = "2025-09-20T13:00:00Z", value_type = String)]
+    pub end_date: DateTime<Utc>,
+    #[schema(example = "2025-09-20T13:00:00Z", value_type = String)]
+    pub start_date: DateTime<Utc>,
+    pub price: f64,
+    pub is_online: bool,
+    pub description: String,
+    pub detail_link: String,
+    pub location: Option<String>,
+}
+
+impl ZodValidate for EventsUpdateRequestDto {
+    fn zod_validate(value: &serde_json::Value) -> Result<Self, String> {
+        serde_json::from_value(value.clone()).map_err(|e| e.to_string())
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct EventsListItemDto {
+    pub id: String,
+    pub name: String,
+    pub description: String,
+    pub detail_link: String,
+    pub price: f64,
+    pub is_online: bool,
+    pub start_date: String,
+    pub end_date: String,
+    pub created_at: String,
+    pub location: Option<String>,
+    pub is_deleted: bool,
+}
+
+impl From<EventEntity> for EventsListItemDto {
+    fn from(e: EventEntity) -> Self {
+        EventsListItemDto {
+            id: e.id.to_string(),
+            name: e.name,
+            description: e.description,
+            detail_link: e.detail_link,
+            price: e.price,
+            is_online: e.is_online,
+            start_date: e.start_date.to_rfc3339(),
+            end_date: e.end_date.to_rfc3339(),
+            created_at: e.created_at.to_rfc3339(),
+            location: e.location,
+            is_deleted: e.is_deleted,
+        }
+    }
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, ToSchema)]
+pub struct EventsDetailItemDto {
+    pub id: String,
+    pub name: String,
+    pub description: String,
+    pub detail_link: String,
+    pub price: f64,
+    pub is_online: bool,
+    pub start_date: String,
+    pub end_date: String,
+    pub created_at: String,
+    pub updated_at: String,
+    pub location: Option<String>,
+}
+
+impl From<EventEntity> for EventsDetailItemDto {
+    fn from(e: EventEntity) -> Self {
+        EventsDetailItemDto {
+            id: e.id.to_string(),
+            name: e.name,
+            description: e.description,
+            detail_link: e.detail_link,
+            price: e.price,
+            is_online: e.is_online,
+            start_date: e.start_date.to_rfc3339(),
+            end_date: e.end_date.to_rfc3339(),
+            created_at: e.created_at.to_rfc3339(),
+            updated_at: e.updated_at.to_rfc3339(),
+            location: e.location,
+        }
+    }
+}

imphnen-cms/src/events/infrastructure/http/handlers.rs

@@ -0,0 +1,160 @@
+use std::sync::Arc;
+use axum::{Extension, extract::Path, http::HeaderMap, response::{IntoResponse, Response}};
+use paginator_axum::PaginationQuery;
+use paginator_utils::PaginatorResponse;
+use uuid::Uuid;
+use imphnen_libs::{AppState, ValidatedJson};
+use imphnen_utils::{ApiSuccess, ApiPaginated, ApiMessage};
+use imphnen_entities::ResponseSuccessDto;
+use imphnen_iam::{PermissionsEnum, require_permissions};
+use imphnen_utils::AppError;
+use super::dto::{EventsCreateRequestDto, EventsDetailItemDto, EventsListItemDto, EventsUpdateRequestDto};
+use crate::events::domain::EventService;
+
+#[utoipa::path(
+    get,
+    path = "/v1/cms/landing/events",
+    params(
+        ("page" = Option<i64>, Query, description = "Page number"),
+        ("per_page" = Option<i64>, Query, description = "Items per page"),
+        ("search" = Option<String>, Query, description = "Search keyword"),
+        ("sort_by" = Option<String>, Query, description = "Sort by field"),
+        ("order" = Option<String>, Query, description = "Order ASC or DESC"),
+    ),
+    responses(
+        (status = 200, description = "[PUBLIC] Get event list")
+    ),
+    tag = "Events"
+)]
+pub async fn get_event_list(
+    Extension(service): Extension<Arc<dyn EventService>>,
+    PaginationQuery(params): PaginationQuery,
+) -> Response {
+    match service.list(params).await {
+        Ok(result) => {
+            let mapped = PaginatorResponse {
+                data: result.data.into_iter().map(EventsListItemDto::from).collect::<Vec<_>>(),
+                meta: result.meta,
+            };
+            ApiPaginated(mapped).into_response()
+        }
+        Err(e) => ApiMessage::new(axum::http::StatusCode::BAD_REQUEST, e.to_string()).into_response(),
+    }
+}
+
+#[utoipa::path(
+    get,
+    path = "/v1/cms/landing/events/detail/{id}",
+    params(
+        ("id" = String, Path, description = "Event ID")
+    ),
+    responses(
+        (status = 200, description = "[PUBLIC] Get event by ID", body = ResponseSuccessDto<EventsDetailItemDto>)
+    ),
+    tag = "Events"
+)]
+pub async fn get_event_by_id(
+    Extension(service): Extension<Arc<dyn EventService>>,
+    Path(id): Path<String>,
+) -> Response {
+    let uuid = match Uuid::parse_str(&id) {
+        Ok(u) => u,
+        Err(e) => return ApiMessage::new(axum::http::StatusCode::BAD_REQUEST, format!("Invalid UUID: {e}")).into_response(),
+    };
+    match service.get(uuid).await {
+        Ok(event) => ApiSuccess(EventsDetailItemDto::from(event)).into_response(),
+        Err(e) => ApiMessage::new(axum::http::StatusCode::NOT_FOUND, e.to_string()).into_response(),
+    }
+}
+
+#[utoipa::path(
+    post,
+    security(("Bearer" = [])),
+    path = "/v1/cms/landing/events/create",
+    request_body = EventsCreateRequestDto,
+    responses(
+        (status = 201, description = "[ADMIN] Create new event")
+    ),
+    tag = "Events"
+)]
+pub async fn post_create_event(
+    headers: HeaderMap,
+    Extension(state): Extension<AppState>,
+    Extension(service): Extension<Arc<dyn EventService>>,
+    ValidatedJson(payload): ValidatedJson<EventsCreateRequestDto>,
+) -> Result<impl IntoResponse, AppError> {
+    require_permissions!(headers, state, [PermissionsEnum::Administrator], {
+        let entity = payload.into();
+        service.create(entity).await?;
+        Ok(ApiMessage::created("Event created"))
+    })
+}
+
+#[utoipa::path(
+    patch,
+    security(("Bearer" = [])),
+    path = "/v1/cms/landing/events/update/{id}",
+    params(
+        ("id" = String, Path, description = "Event ID")
+    ),
+    request_body = EventsUpdateRequestDto,
+    responses(
+        (status = 200, description = "[ADMIN] Update event")
+    ),
+    tag = "Events"
+)]
+pub async fn patch_update_event(
+    headers: HeaderMap,
+    Extension(state): Extension<AppState>,
+    Extension(service): Extension<Arc<dyn EventService>>,
+    Path(id): Path<String>,
+    ValidatedJson(payload): ValidatedJson<EventsUpdateRequestDto>,
+) -> Result<impl IntoResponse, AppError> {
+    require_permissions!(headers, state, [PermissionsEnum::Administrator], {
+        let uuid = Uuid::parse_str(&id)
+            .map_err(|e| AppError::BadRequestError(format!("Invalid UUID: {e}")))?;
+        let existing = service.get(uuid).await?;
+        let entity = crate::events::domain::EventEntity {
+            id: existing.id,
+            name: payload.name,
+            description: payload.description,
+            detail_link: payload.detail_link,
+            price: payload.price,
+            is_online: payload.is_online,
+            location: payload.location,
+            start_date: payload.start_date,
+            end_date: payload.end_date,
+            is_deleted: existing.is_deleted,
+            created_at: existing.created_at,
+            updated_at: chrono::Utc::now(),
+        };
+        service.update(entity).await?;
+        Ok(ApiMessage::ok("Event updated"))
+    })
+}
+
+#[utoipa::path(
+    delete,
+    security(("Bearer" = [])),
+    path = "/v1/cms/landing/events/delete/{id}",
+    params(
+        ("id" = String, Path, description = "Event ID")
+    ),
+    responses(
+        (status = 200, description = "[ADMIN] Soft delete event")
+    ),
+    tag = "Events"
+)]
+pub async fn delete_event(
+    headers: HeaderMap,
+    Extension(state): Extension<AppState>,
+    Extension(service): Extension<Arc<dyn EventService>>,
+    Path(id): Path<String>,
+) -> Result<impl IntoResponse, AppError> {
+    require_permissions!(headers, state, [PermissionsEnum::Administrator], {
+        let uuid = Uuid::parse_str(&id)
+            .map_err(|e| AppError::BadRequestError(format!("Invalid UUID: {e}")))?;
+        service.delete(uuid).await?;
+        Ok(ApiMessage::ok("Event deleted"))
+    })
+}

imphnen-cms/src/events/infrastructure/http/mod.rs

@@ -0,0 +1,5 @@
+pub mod dto;
+pub mod handlers;
+pub mod routes;
+
+pub use routes::{events_public_routes, events_protected_routes};

imphnen-cms/src/events/infrastructure/http/routes.rs

@@ -0,0 +1,31 @@
+use std::sync::Arc;
+use axum::{Router, routing::{delete, get, patch, post}, Extension};
+use sea_orm::DatabaseConnection;
+use crate::events::application::EventServiceImpl;
+use crate::events::domain::EventService;
+use crate::events::infrastructure::persistence::PostgresEventRepository;
+use super::handlers::{
+    delete_event, get_event_by_id, get_event_list, patch_update_event, post_create_event,
+};
+
+fn build_service(db: DatabaseConnection) -> Arc<dyn EventService> {
+    let repo = Arc::new(PostgresEventRepository::new(db));
+    Arc::new(EventServiceImpl::new(repo))
+}
+
+pub fn events_public_routes(db: DatabaseConnection) -> Router {
+    let service = build_service(db);
+    Router::new()
+        .route("/cms/landing/events", get(get_event_list))
+        .route("/cms/landing/events/detail/{id}", get(get_event_by_id))
+        .layer(Extension(service))
+}
+
+pub fn events_protected_routes(db: DatabaseConnection) -> Router {
+    let service = build_service(db);
+    Router::new()
+        .route("/cms/landing/events/create", post(post_create_event))
+        .route("/cms/landing/events/update/{id}", patch(patch_update_event))
+        .route("/cms/landing/events/delete/{id}", delete(delete_event))
+        .layer(Extension(service))
+}

imphnen-cms/src/events/infrastructure/mod.rs

@@ -0,0 +1,2 @@
+pub mod http;
+pub mod persistence;

imphnen-cms/src/events/infrastructure/persistence/mod.rs

@@ -0,0 +1,3 @@
+pub mod postgres_event_repository;
+
+pub use postgres_event_repository::PostgresEventRepository;

imphnen-cms/src/events/infrastructure/persistence/postgres_event_repository.rs

@@ -0,0 +1,149 @@
+use std::sync::Arc;
+use async_trait::async_trait;
+use sea_orm::prelude::*;
+use sea_orm::{ActiveValue, Order, QueryOrder, PaginatorTrait};
+use paginator_rs::{PaginationParams, SortDirection};
+use paginator_utils::{PaginatorResponse, PaginatorResponseMeta};
+use uuid::Uuid;
+use imphnen_utils::AppError;
+use imphnen_entities::seaorm::common::events::{
+    Entity as EventsEntity, Column as EventsColumn,
+    ActiveModel as EventsActiveModel, Model as EventsModel,
+};
+use crate::events::domain::{event::EventEntity, repository::EventRepository};
+
+fn to_entity(model: EventsModel) -> EventEntity {
+    EventEntity {
+        id: model.id,
+        name: model.name,
+        description: model.description,
+        detail_link: model.detail_link,
+        price: model.price,
+        is_online: model.is_online,
+        is_deleted: model.is_deleted,
+        location: model.location,
+        start_date: model.start_date,
+        end_date: model.end_date,
+        created_at: model.created_at,
+        updated_at: model.updated_at,
+    }
+}
+
+pub struct PostgresEventRepository {
+    db: Arc<DatabaseConnection>,
+}
+
+impl PostgresEventRepository {
+    pub fn new(db: DatabaseConnection) -> Self {
+        Self { db: Arc::new(db) }
+    }
+}
+
+#[async_trait]
+impl EventRepository for PostgresEventRepository {
+    async fn find_all(&self, params: PaginationParams) -> Result<PaginatorResponse<EventEntity>, AppError> {
+        let page = params.page.max(1);
+        let per_page = params.per_page.clamp(1, 100);
+
+        let mut query = EventsEntity::find()
+            .filter(EventsColumn::IsDeleted.eq(false));
+
+        if let Some(ref search) = params.search {
+            query = query.filter(EventsColumn::Name.contains(&search.query));
+        }
+
+        query = match params.sort_by.as_deref() {
+            Some("name") => match params.sort_direction {
+                Some(SortDirection::Desc) => query.order_by(EventsColumn::Name, Order::Desc),
+                _ => query.order_by(EventsColumn::Name, Order::Asc),
+            },
+            _ => match params.sort_direction {
+                Some(SortDirection::Asc) => query.order_by(EventsColumn::CreatedAt, Order::Asc),
+                _ => query.order_by(EventsColumn::CreatedAt, Order::Desc),
+            },
+        };
+
+        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 events = paginator.fetch_page((page - 1) as u64).await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+
+        let data = events.into_iter().map(to_entity).collect();
+        let meta = PaginatorResponseMeta::new(page, per_page, total as u32);
+        Ok(PaginatorResponse { data, meta })
+    }
+
+    async fn find_by_id(&self, id: Uuid) -> Result<EventEntity, AppError> {
+        let event = EventsEntity::find_by_id(id)
+            .filter(EventsColumn::IsDeleted.eq(false))
+            .one(self.db.as_ref())
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?
+            .ok_or_else(|| AppError::NotFoundError("Event not found".to_string()))?;
+
+        Ok(to_entity(event))
+    }
+
+    async fn create(&self, entity: EventEntity) -> Result<(), AppError> {
+        let active_model = EventsActiveModel {
+            id: ActiveValue::Set(entity.id),
+            name: ActiveValue::Set(entity.name),
+            description: ActiveValue::Set(entity.description),
+            detail_link: ActiveValue::Set(entity.detail_link),
+            price: ActiveValue::Set(entity.price),
+            is_online: ActiveValue::Set(entity.is_online),
+            is_deleted: ActiveValue::Set(false),
+            location: ActiveValue::Set(entity.location),
+            start_date: ActiveValue::Set(entity.start_date),
+            end_date: ActiveValue::Set(entity.end_date),
+            created_at: ActiveValue::Set(chrono::Utc::now()),
+            updated_at: ActiveValue::Set(chrono::Utc::now()),
+        };
+
+        EventsEntity::insert(active_model)
+            .exec(self.db.as_ref())
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+
+        Ok(())
+    }
+
+    async fn update(&self, entity: EventEntity) -> Result<(), AppError> {
+        let mut active_model: EventsActiveModel = EventsEntity::find_by_id(entity.id)
+            .one(self.db.as_ref())
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?
+            .ok_or_else(|| AppError::NotFoundError("Event not found".to_string()))?
+            .into();
+
+        active_model.name = ActiveValue::Set(entity.name);
+        active_model.description = ActiveValue::Set(entity.description);
+        active_model.detail_link = ActiveValue::Set(entity.detail_link);
+        active_model.price = ActiveValue::Set(entity.price);
+        active_model.is_online = ActiveValue::Set(entity.is_online);
+        active_model.location = ActiveValue::Set(entity.location);
+        active_model.start_date = ActiveValue::Set(entity.start_date);
+        active_model.end_date = ActiveValue::Set(entity.end_date);
+        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: EventsActiveModel = EventsEntity::find_by_id(id)
+            .one(self.db.as_ref())
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?
+            .ok_or_else(|| AppError::NotFoundError("Event 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(())
+    }
+}

imphnen-cms/src/events/mod.rs

@@ -0,0 +1,5 @@
+pub mod application;
+pub mod domain;
+pub mod infrastructure;
+
+pub use infrastructure::http::{events_public_routes, events_protected_routes};