feat(server): integrate AppState, ModuleRegistry, health check, and graceful shutdown

- Add AppState with DB, Config, EventBus, ModuleRegistry via Axum State
- ModuleRegistry now uses Arc for Clone support, builder-pattern register()
- Add /api/v1/health endpoint returning status, version, registered modules
- Add graceful shutdown on CTRL+C / SIGTERM
- erp-common utils: ID generation, timestamp helpers, code generator with tests
- Config structs now derive Clone for state sharing
- Update wiki to reflect Phase 1 completion

crates/erp-common/src/utils.rs

@@ -1,3 +1,55 @@
-/// Shared utility functions for the ERP platform.
-#[allow(dead_code)]
-pub fn noop() {}
+use chrono::{DateTime, Utc};
+use uuid::Uuid;
+
+/// 生成 UUID v7（时间排序 + 唯一性）
+pub fn generate_id() -> Uuid {
+    Uuid::now_v7()
+}
+
+/// 获取当前 UTC 时间
+pub fn now() -> DateTime<Utc> {
+    Utc::now()
+}
+
+/// 软删除时间戳 — 返回 None 表示未删除
+pub const fn not_deleted() -> Option<DateTime<Utc>> {
+    None
+}
+
+/// 生成租户级别的编号前缀
+/// 格式: {prefix}-{timestamp_seconds}-{random_4hex}
+pub fn generate_code(prefix: &str) -> String {
+    let ts = Utc::now().timestamp() as u32;
+    let random = (Uuid::now_v7().as_u128() & 0xFFFF) as u16;
+    format!("{}-{:08x}-{:04x}", prefix, ts, random)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_generate_id_returns_valid_uuid() {
+        let id = generate_id();
+        assert!(!id.is_nil());
+    }
+
+    #[test]
+    fn test_generate_code_format() {
+        let code = generate_code("USR");
+        assert!(code.starts_with("USR-"));
+        assert_eq!(code.len(), "USR-".len() + 8 + 1 + 4);
+    }
+
+    #[test]
+    fn test_not_deleted_returns_none() {
+        assert!(not_deleted().is_none());
+    }
+
+    #[test]
+    fn test_generate_ids_are_unique() {
+        let ids: std::collections::HashSet<Uuid> =
+            (0..100).map(|_| generate_id()).collect();
+        assert_eq!(ids.len(), 100);
+    }
+}

crates/erp-core/src/module.rs

@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use axum::Router;
 use uuid::Uuid;
 
@@ -38,19 +40,25 @@ pub trait ErpModule: Send + Sync {
     }
 }
 
-/// 模块注册器
+/// 模块注册器 — 用 Arc 包装使其可 Clone（用于 Axum State）
+#[derive(Clone, Default)]
 pub struct ModuleRegistry {
-    modules: Vec<Box<dyn ErpModule>>,
+    modules: Arc<Vec<Arc<dyn ErpModule>>>,
 }
 
 impl ModuleRegistry {
     pub fn new() -> Self {
-        Self { modules: vec![] }
+        Self {
+            modules: Arc::new(vec![]),
+        }
     }
 
-    pub fn register(&mut self, module: Box<dyn ErpModule>) {
+    pub fn register(mut self, module: impl ErpModule + 'static) -> Self {
         tracing::info!(module = module.name(), version = module.version(), "Module registered");
-        self.modules.push(module);
+        let mut modules = (*self.modules).clone();
+        modules.push(Arc::new(module));
+        self.modules = Arc::new(modules);
+        self
     }
 
     pub fn build_router(&self, base: Router) -> Router {
@@ -60,12 +68,12 @@ impl ModuleRegistry {
     }
 
     pub fn register_handlers(&self, bus: &EventBus) {
-        for module in &self.modules {
+        for module in self.modules.iter() {
             module.register_event_handlers(bus);
         }
     }
 
-    pub fn modules(&self) -> &[Box<dyn ErpModule>] {
+    pub fn modules(&self) -> &[Arc<dyn ErpModule>] {
         &self.modules
     }
 }

crates/erp-server/src/config.rs

@@ -1,6 +1,6 @@
 use serde::Deserialize;
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 pub struct AppConfig {
     pub server: ServerConfig,
     pub database: DatabaseConfig,
@@ -9,32 +9,32 @@ pub struct AppConfig {
     pub log: LogConfig,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 pub struct ServerConfig {
     pub host: String,
     pub port: u16,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 pub struct DatabaseConfig {
     pub url: String,
     pub max_connections: u32,
     pub min_connections: u32,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 pub struct RedisConfig {
     pub url: String,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 pub struct JwtConfig {
     pub secret: String,
     pub access_token_ttl: String,
     pub refresh_token_ttl: String,
 }
 
-#[derive(Debug, Deserialize)]
+#[derive(Debug, Clone, Deserialize)]
 pub struct LogConfig {
     pub level: String,
 }

crates/erp-server/src/handlers/health.rs

@@ -0,0 +1,36 @@
+use axum::extract::State;
+use axum::response::Json;
+use axum::routing::get;
+use axum::Router;
+use serde::Serialize;
+
+use crate::state::AppState;
+
+#[derive(Debug, Serialize)]
+pub struct HealthResponse {
+    pub status: String,
+    pub version: String,
+    pub modules: Vec<String>,
+}
+
+/// GET /api/v1/health
+///
+/// 服务健康检查，返回运行状态和已注册模块列表
+pub async fn health_check(State(state): State<AppState>) -> Json<HealthResponse> {
+    let modules = state
+        .module_registry
+        .modules()
+        .iter()
+        .map(|m| m.name().to_string())
+        .collect();
+
+    Json(HealthResponse {
+        status: "ok".to_string(),
+        version: env!("CARGO_PKG_VERSION").to_string(),
+        modules,
+    })
+}
+
+pub fn health_check_router() -> Router<AppState> {
+    Router::new().route("/api/v1/health", get(health_check))
+}

crates/erp-server/src/handlers/mod.rs

@@ -0,0 +1 @@
+pub mod health;

crates/erp-server/src/main.rs

@@ -1,10 +1,14 @@
 mod config;
 mod db;
+mod handlers;
+mod state;
 
 use axum::Router;
 use config::AppConfig;
-use erp_server_migration::Migrator;
+use erp_core::events::EventBus;
+use erp_core::module::ModuleRegistry;
 use erp_server_migration::MigratorTrait;
+use state::AppState;
 use tracing_subscriber::EnvFilter;
 
 #[tokio::main]
@@ -21,27 +25,85 @@ async fn main() -> anyhow::Result<()> {
         .json()
         .init();
 
-    tracing::info!("ERP Server starting...");
+    tracing::info!(version = env!("CARGO_PKG_VERSION"), "ERP Server starting...");
 
     // Connect to database
     let db = db::connect(&config.database).await?;
 
     // Run migrations
-    Migrator::up(&db, None).await?;
+    erp_server_migration::Migrator::up(&db, None).await?;
     tracing::info!("Database migrations applied");
 
     // Connect to Redis
     let _redis_client = redis::Client::open(&config.redis.url[..])?;
     tracing::info!("Redis client created");
 
-    // Build app
-    let app = Router::new()
-        .fallback(|| async { axum::Json(serde_json::json!({"error": "Not found"})) });
+    // Initialize event bus (capacity 1024 events)
+    let event_bus = EventBus::new(1024);
 
-    let addr = format!("{}:{}", config.server.host, config.server.port);
+    // Initialize module registry
+    let registry = ModuleRegistry::new();
+    // Phase 2+ will register modules here:
+    // let registry = registry.register(Box::new(erp_auth::AuthModule::new(db.clone())));
+    tracing::info!(module_count = registry.modules().len(), "Modules registered");
+
+    // Register event handlers
+    registry.register_handlers(&event_bus);
+
+    let host = config.server.host.clone();
+    let port = config.server.port;
+
+    // Build shared state
+    let state = AppState {
+        db,
+        config,
+        event_bus,
+        module_registry: registry,
+    };
+
+    // Build API router with versioning
+    let api_v1 = Router::new().merge(handlers::health::health_check_router());
+
+    // Build application router
+    let app = Router::new().merge(api_v1).with_state(state);
+
+    let addr = format!("{}:{}", host, port);
     let listener = tokio::net::TcpListener::bind(&addr).await?;
-    tracing::info!("Server listening on {}", addr);
-    axum::serve(listener, app).await?;
+    tracing::info!(addr = %addr, "Server listening");
 
+    // Graceful shutdown on CTRL+C
+    axum::serve(listener, app)
+        .with_graceful_shutdown(shutdown_signal())
+        .await?;
+
+    tracing::info!("Server shutdown complete");
     Ok(())
 }
+
+async fn shutdown_signal() {
+    let ctrl_c = async {
+        tokio::signal::ctrl_c()
+            .await
+            .expect("failed to install CTRL+C handler");
+    };
+
+    #[cfg(unix)]
+    let terminate = async {
+        tokio::signal::unix::signal(tokio::signal::unix::SignalKind::terminate())
+            .expect("failed to install signal handler")
+            .recv()
+            .await;
+    };
+
+    #[cfg(not(unix))]
+    let terminate = std::future::pending::<()>();
+
+    tokio::select! {
+        _ = ctrl_c => {
+            tracing::info!("Received CTRL+C, shutting down gracefully...");
+        },
+        _ = terminate => {
+            tracing::info!("Received SIGTERM, shutting down gracefully...");
+        },
+    }
+}

crates/erp-server/src/state.rs

@@ -0,0 +1,23 @@
+use axum::extract::FromRef;
+use sea_orm::DatabaseConnection;
+
+use crate::config::AppConfig;
+use erp_core::events::EventBus;
+use erp_core::module::ModuleRegistry;
+
+/// Axum 共享应用状态
+/// 所有 handler 通过 State<AppState> 获取数据库连接、配置等
+#[derive(Clone)]
+pub struct AppState {
+    pub db: DatabaseConnection,
+    pub config: AppConfig,
+    pub event_bus: EventBus,
+    pub module_registry: ModuleRegistry,
+}
+
+/// 允许 handler 直接提取子字段
+impl FromRef<AppState> for DatabaseConnection {
+    fn from_ref(state: &AppState) -> Self {
+        state.db.clone()
+    }
+}