feat(proxy): implement log setting, proxy setting, rewrite rule, server block, and SSL certificate services

- Added LogSettingService with CRUD operations for log settings.
- Introduced ProxySettingService for managing proxy settings with CRUD functionality.
- Created RewriteRuleService to handle rewrite rules with full CRUD capabilities.
- Implemented ServerBlockService for managing server blocks, including relationships with access rules and location blocks.
- Added SslCertificateService for managing SSL certificates with create, read, update, and delete operations.
- Updated types.rs to include new service configurations and ensure proper merging of overrides.
- Enhanced existing tests to cover new functionalities and ensure correctness.

apps/nxmesh-master/src/service/proxy/upstream/mod.rs

@@ -0,0 +1,140 @@
+use sea_orm::{ActiveModelTrait, ActiveValue::Set, DatabaseConnection, EntityTrait, prelude::*};
+use uuid::Uuid;
+
+use crate::service::proxy::types::{
+    OverrideRef, ProxyServiceError, ProxyServiceResult, UpstreamConfig,
+};
+
+pub struct CreateUpstreamParams {
+    pub config_id: Uuid,
+    pub name: String,
+    pub target_host: String,
+    pub target_port: i32,
+    pub metadata: Option<serde_json::Value>,
+    pub override_of_id: Option<Uuid>,
+}
+
+pub struct UpdateUpstreamParams {
+    pub name: Option<String>,
+    pub target_host: Option<String>,
+    pub target_port: Option<i32>,
+    pub metadata: Option<Option<serde_json::Value>>,
+    pub override_of_id: Option<Option<Uuid>>,
+}
+
+fn model_to_config(model: crate::db::entities::upstream::Model) -> UpstreamConfig {
+    UpstreamConfig {
+        id: model.id,
+        name: model.name,
+        target_host: model.target_host,
+        target_port: model.target_port,
+        metadata: model.metadata,
+        override_of_id: model.override_of_id,
+        location_blocks: vec![],
+    }
+}
+
+#[async_trait::async_trait]
+pub trait UpstreamService: Send + Sync + 'static {
+    async fn get(&self, id: Uuid) -> ProxyServiceResult<UpstreamConfig>;
+    async fn list_by_config(&self, config_id: Uuid) -> ProxyServiceResult<Vec<UpstreamConfig>>;
+    async fn create(&self, params: CreateUpstreamParams) -> ProxyServiceResult<UpstreamConfig>;
+    async fn update(
+        &self,
+        id: Uuid,
+        params: UpdateUpstreamParams,
+    ) -> ProxyServiceResult<UpstreamConfig>;
+    async fn delete(&self, id: Uuid) -> ProxyServiceResult<bool>;
+}
+
+pub(crate) struct UpstreamServiceImpl {
+    db: DatabaseConnection,
+}
+
+impl UpstreamServiceImpl {
+    pub fn new(db: DatabaseConnection) -> Self {
+        Self { db }
+    }
+}
+
+#[async_trait::async_trait]
+impl UpstreamService for UpstreamServiceImpl {
+    async fn get(&self, id: Uuid) -> ProxyServiceResult<UpstreamConfig> {
+        use crate::db::entities::upstream;
+
+        let model = upstream::Entity::find_by_id(id)
+            .one(&self.db)
+            .await?
+            .ok_or(ProxyServiceError::ConfigNotFound)?;
+
+        Ok(model_to_config(model))
+    }
+
+    async fn list_by_config(&self, config_id: Uuid) -> ProxyServiceResult<Vec<UpstreamConfig>> {
+        use crate::db::entities::upstream;
+
+        let models = upstream::Entity::find()
+            .filter(upstream::Column::ConfigId.eq(config_id))
+            .all(&self.db)
+            .await?;
+
+        Ok(models.into_iter().map(model_to_config).collect())
+    }
+
+    async fn create(&self, params: CreateUpstreamParams) -> ProxyServiceResult<UpstreamConfig> {
+        use crate::db::entities::upstream::ActiveModel;
+
+        let model = ActiveModel {
+            id: Set(Uuid::new_v4()),
+            config_id: Set(params.config_id),
+            name: Set(params.name),
+            target_host: Set(params.target_host),
+            target_port: Set(params.target_port),
+            metadata: Set(params.metadata),
+            override_of_id: Set(params.override_of_id),
+        };
+
+        let result = model.insert(&self.db).await?;
+        Ok(model_to_config(result))
+    }
+
+    async fn update(
+        &self,
+        id: Uuid,
+        params: UpdateUpstreamParams,
+    ) -> ProxyServiceResult<UpstreamConfig> {
+        use crate::db::entities::upstream::{ActiveModel, Entity as UpstreamEntity};
+
+        let existing = UpstreamEntity::find_by_id(id)
+            .one(&self.db)
+            .await?
+            .ok_or(ProxyServiceError::ConfigNotFound)?;
+
+        let mut model: ActiveModel = existing.into();
+        if let Some(name) = params.name {
+            model.name = Set(name);
+        }
+        if let Some(target_host) = params.target_host {
+            model.target_host = Set(target_host);
+        }
+        if let Some(target_port) = params.target_port {
+            model.target_port = Set(target_port);
+        }
+        if let Some(metadata) = params.metadata {
+            model.metadata = Set(metadata);
+        }
+        if let Some(override_of_id) = params.override_of_id {
+            model.override_of_id = Set(override_of_id);
+        }
+
+        let result = model.update(&self.db).await?;
+        Ok(model_to_config(result))
+    }
+
+    async fn delete(&self, id: Uuid) -> ProxyServiceResult<bool> {
+        let result = crate::db::entities::upstream::Entity::delete_by_id(id)
+            .exec(&self.db)
+            .await?;
+        Ok(result.rows_affected > 0)
+    }
+}