admin/CC-Switch
1
0
Fork 0
mirror of https://github.com/farion1231/cc-switch.git synced 2026-08-01 12:22:09 +08:00
Code Issues Packages Projects Releases Wiki Activity

refactor(backend): complete phase 1 - unified error handling (100%)

Browse Source 
Completed the remaining migrations for Phase 1 of backend refactoring plan,
achieving 100% coverage of unified error handling with AppError.

## Changes

### Fully Migrated Modules (Result<T, String> → Result<T, AppError>)

- **claude_plugin.rs** (35 lines changed)
  - Migrated 7 public functions: claude_config_path, ensure_claude_dir_exists,
    read_claude_config, write_claude_config, clear_claude_config,
    claude_config_status, is_claude_config_applied
  - Used AppError::io(), AppError::JsonSerialize, AppError::Config
  - Simplified error handling with helper functions

- **settings.rs** (14 lines changed)
  - Migrated AppSettings::save() and update_settings()
  - Used AppError::io() for file operations
  - Used AppError::JsonSerialize for JSON serialization

- **import_export.rs** (67 lines changed)
  - Migrated 8 functions: create_backup, cleanup_old_backups,
    sync_current_providers_to_live, sync_current_provider_for_app,
    sync_codex_live, sync_claude_live, export_config_to_file,
    import_config_from_file, sync_current_providers_live
  - Used AppError::io(), AppError::json(), AppError::Config
  - Added proper error context with file paths and provider IDs
  - Used AppError::Message for temporary bridge with String-based APIs

### Adapted Interface Calls

- **commands.rs** (30 lines changed)
  - Updated 15 Tauri command handlers to use .map_err(|e| e.to_string())
  - Changed from implicit Into::into to explicit e.to_string()
  - Maintained Result<T, String> interface for Tauri (frontend compatibility)
  - Affected commands: Claude MCP (5), Claude plugin (5), settings (1)

- **mcp.rs** (2 lines changed)
  - Updated claude_mcp::set_mcp_servers_map call
  - Changed from .map_err(Into::into) to .map_err(|e| e.to_string())

## Statistics

- Files changed: 5
- Lines changed: +82/-66 (net +16)
- Compilation: ✅ Success (8.42s, 0 warnings)
- Tests: ✅ 4/4 passed

## Benefits

- **Type Safety**: All infrastructure modules now use strongly-typed AppError
- **Error Context**: File paths and operation types preserved in error chain
- **Code Quality**: Removed ~30 instances of .map_err(|e| format!("...", e))
- **Maintainability**: Consistent error handling pattern across codebase
- **Debugging**: Error source chain preserved with #[source] attribute

## Phase 1 Status: ✅ 100% Complete

All modules migrated:
- ✅ config.rs (Phase 1.1)
- ✅ claude_mcp.rs (Phase 1.1)
- ✅ codex_config.rs (Phase 1.1)
- ✅ app_config.rs (Phase 1.1)
- ✅ store.rs (Phase 1.1)
- ✅ claude_plugin.rs (Phase 1.2)
- ✅ settings.rs (Phase 1.2)
- ✅ import_export.rs (Phase 1.2)
- ✅ commands.rs (interface adaptation complete)
- ✅ mcp.rs (interface adaptation complete)

Ready for Phase 2: Splitting commands.rs by domain.

Co-authored-by: Claude <noreply@anthropic.com>
This commit is contained in:
Jason
2025-10-27 16:48:08 +08:00
parent c01e495eea
commit 1cc0e4bc8d
5 changed files with 82 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src-tauri/src/import_export.rs
+40 -27
View File
@@ -1,4 +1,5 @@
use crate::app_config::{AppType, MultiAppConfig};
use crate::error::AppError;
use crate::provider::Provider;
use chrono::Utc;
use serde_json::{json, Value};
@@ -9,7 +10,7 @@ use std::path::PathBuf;
const MAX_BACKUPS: usize = 10;
/// 创建配置文件备份
pub fn create_backup(config_path: &PathBuf) -> Result<String, String> {
pub fn create_backup(config_path: &PathBuf) -> Result<String, AppError> {
if !config_path.exists() {
return Ok(String::new());
}
@@ -19,17 +20,16 @@ pub fn create_backup(config_path: &PathBuf) -> Result<String, String> {
let backup_dir = config_path
.parent()
.ok_or("Invalid config path")?
.ok_or_else(|| AppError::Config("Invalid config path".into()))?
.join("backups");
// 创建备份目录
fs::create_dir_all(&backup_dir)
.map_err(|e| format!("Failed to create backup directory: {}", e))?;
fs::create_dir_all(&backup_dir).map_err(|e| AppError::io(&backup_dir, e))?;
let backup_path = backup_dir.join(format!("{}.json", backup_id));
// 复制配置文件到备份
fs::copy(config_path, backup_path).map_err(|e| format!("Failed to create backup: {}", e))?;
fs::copy(config_path, &backup_path).map_err(|e| AppError::io(&backup_path, e))?;
// 备份完成后清理旧的备份文件（仅保留最近 MAX_BACKUPS 份）
cleanup_old_backups(&backup_dir, MAX_BACKUPS)?;
@@ -37,7 +37,7 @@ pub fn create_backup(config_path: &PathBuf) -> Result<String, String> {
Ok(backup_id)
}
fn cleanup_old_backups(backup_dir: &PathBuf, retain: usize) -> Result<(), String> {
fn cleanup_old_backups(backup_dir: &PathBuf, retain: usize) -> Result<(), AppError> {
if retain == 0 {
return Ok(());
}
@@ -81,7 +81,7 @@ fn cleanup_old_backups(backup_dir: &PathBuf, retain: usize) -> Result<(), String
Ok(())
}
fn sync_current_providers_to_live(config: &mut MultiAppConfig) -> Result<(), String> {
fn sync_current_providers_to_live(config: &mut MultiAppConfig) -> Result<(), AppError> {
sync_current_provider_for_app(config, &AppType::Claude)?;
sync_current_provider_for_app(config, &AppType::Codex)?;
Ok(())
@@ -90,7 +90,7 @@ fn sync_current_providers_to_live(config: &mut MultiAppConfig) -> Result<(), Str
fn sync_current_provider_for_app(
config: &mut MultiAppConfig,
app_type: &AppType,
) -> Result<(), String> {
) -> Result<(), AppError> {
let (current_id, provider) = {
let manager = match config.get_manager(app_type) {
Some(manager) => manager,
@@ -128,26 +128,36 @@ fn sync_codex_live(
config: &mut MultiAppConfig,
provider_id: &str,
provider: &Provider,
) -> Result<(), String> {
) -> Result<(), AppError> {
use serde_json::Value;
let settings = provider
.settings_config
.as_object()
.ok_or_else(|| format!("供应商 {} 的 Codex 配置必须是对象", provider_id))?;
.ok_or_else(|| {
AppError::Config(format!(
"供应商 {} 的 Codex 配置必须是对象",
provider_id
))
})?;
let auth = settings
.get("auth")
.ok_or_else(|| format!("供应商 {} 的 Codex 配置缺少 auth 字段", provider_id))?;
.ok_or_else(|| {
AppError::Config(format!(
"供应商 {} 的 Codex 配置缺少 auth 字段",
provider_id
))
})?;
if !auth.is_object() {
return Err(format!(
return Err(AppError::Config(format!(
"供应商 {} 的 Codex auth 配置必须是 JSON 对象",
provider_id
));
)));
}
let cfg_text = settings.get("config").and_then(Value::as_str);
crate::codex_config::write_codex_live_atomic(auth, cfg_text)?;
crate::mcp::sync_enabled_to_codex(config)?;
crate::mcp::sync_enabled_to_codex(config).map_err(AppError::Message)?;
let cfg_text_after = crate::codex_config::read_and_validate_codex_config_text()?;
if let Some(manager) = config.get_manager_mut(&AppType::Codex) {
@@ -168,12 +178,12 @@ fn sync_claude_live(
config: &mut MultiAppConfig,
provider_id: &str,
provider: &Provider,
) -> Result<(), String> {
) -> Result<(), AppError> {
use crate::config::{read_json_file, write_json_file};
let settings_path = crate::config::get_claude_settings_path();
if let Some(parent) = settings_path.parent() {
std::fs::create_dir_all(parent).map_err(|e| format!("创建 Claude 配置目录失败: {}", e))?;
std::fs::create_dir_all(parent).map_err(|e| AppError::io(parent, e))?;
}
write_json_file(&settings_path, &provider.settings_config)?;
@@ -194,10 +204,11 @@ pub async fn export_config_to_file(file_path: String) -> Result<Value, String> {
// 读取当前配置文件
let config_path = crate::config::get_app_config_path();
let config_content = fs::read_to_string(&config_path)
.map_err(|e| format!("Failed to read configuration: {}", e))?;
.map_err(|e| AppError::io(&config_path, e).to_string())?;
// 写入到指定文件
fs::write(&file_path, &config_content).map_err(|e| format!("Failed to write file: {}", e))?;
fs::write(&file_path, &config_content)
.map_err(|e| AppError::io(&file_path, e).to_string())?;
Ok(json!({
"success": true,
@@ -213,27 +224,29 @@ pub async fn import_config_from_file(
state: tauri::State<'_, crate::store::AppState>,
) -> Result<Value, String> {
// 读取导入的文件
let import_content =
fs::read_to_string(&file_path).map_err(|e| format!("Failed to read import file: {}", e))?;
let file_path_ref = std::path::Path::new(&file_path);
let import_content = fs::read_to_string(file_path_ref)
.map_err(|e| AppError::io(file_path_ref, e).to_string())?;
// 验证并解析为配置对象
let new_config: crate::app_config::MultiAppConfig = serde_json::from_str(&import_content)
.map_err(|e| format!("Invalid configuration file: {}", e))?;
let new_config: crate::app_config::MultiAppConfig =
serde_json::from_str(&import_content)
.map_err(|e| AppError::json(file_path_ref, e).to_string())?;
// 备份当前配置
let config_path = crate::config::get_app_config_path();
let backup_id = create_backup(&config_path)?;
let backup_id = create_backup(&config_path).map_err(|e| e.to_string())?;
// 写入新配置到磁盘
fs::write(&config_path, &import_content)
.map_err(|e| format!("Failed to write configuration: {}", e))?;
.map_err(|e| AppError::io(&config_path, e).to_string())?;
// 更新内存中的状态
{
let mut config_state = state
.config
.lock()
.map_err(|e| format!("Failed to lock config: {}", e))?;
.map_err(|e| AppError::from(e).to_string())?;
*config_state = new_config;
}
@@ -253,8 +266,8 @@ pub async fn sync_current_providers_live(
let mut config_state = state
.config
.lock()
.map_err(|e| format!("Failed to lock config: {}", e))?;
sync_current_providers_to_live(&mut config_state)?;
.map_err(|e| AppError::from(e).to_string())?;
sync_current_providers_to_live(&mut config_state).map_err(|e| e.to_string())?;
}
Ok(json!({