Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

15.7 KB
Raw Blame
use std::sync::Arc;

use dbx_core::cloud_sync::{
    apply_sync_snapshot_with_selection, build_sync_snapshot_with_selection, describe_local_sync_state,
    describe_sync_snapshot, finalize_snippet_migration, forget_snippet_passphrase, forget_snippet_token,
    forget_webdav_password, forget_webdav_sync_secrets_passphrase as core_forget_webdav_sync_secrets_passphrase,
    resolve_snippet_passphrase, resolve_snippet_token, resolve_webdav_password, resolve_webdav_sync_secrets_passphrase,
    retry_pending_snippet_cleanup, save_snippet_passphrase,
    save_snippet_sync_id_for_instance as core_save_snippet_sync_id, save_snippet_token, save_webdav_password,
    save_webdav_sync_secrets_preference as core_save_webdav_sync_secrets_preference, snippet_saved_passphrase_status,
    snippet_saved_token_status, snippet_sync_settings_for_instance as core_snippet_sync_settings,
    webdav_saved_password_status, webdav_sync_secrets_status as core_webdav_sync_secrets_status, ApplySnapshotOptions,
    ApplySnapshotSummary, SnippetPassphraseStatus, SnippetProvider, SnippetSyncClient, SnippetSyncConfig,
    SnippetSyncSettings, SnippetSyncSummary, SnippetTokenStatus, SyncExportOptions, SyncSelection, SyncSnapshotCatalog,
    WebDavClient, WebDavConfig, WebDavPasswordStatus, WebDavSyncSecretsStatus, WebDavSyncSummary,
};
use dbx_core::storage::DesktopSettings;
use dbx_core::storage::{MigrationPreflight, MigrationReport};
use serde::{Deserialize, Serialize};
use tauri::State;

use dbx_core::connection::AppState;

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct WebDavDownloadResult {
    pub summary: WebDavSyncSummary,
    pub editor_settings: Option<serde_json::Value>,
    pub desktop_settings: DesktopSettings,
    pub apply_summary: ApplySnapshotSummary,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SnippetDownloadResult {
    pub summary: SnippetSyncSummary,
    pub editor_settings: Option<serde_json::Value>,
    pub desktop_settings: DesktopSettings,
    pub apply_summary: ApplySnapshotSummary,
}

#[tauri::command]
pub async fn migration_status(
    state: State<'_, Arc<AppState>>,
    retry: Option<bool>,
) -> Result<MigrationPreflight, String> {
    if retry.unwrap_or(false) {
        state.storage.retry_data_migration_inspection().await
    } else {
        state.storage.inspect_data_migration().await
    }
}

#[tauri::command]
pub async fn migration_start(
    state: State<'_, Arc<AppState>>,
    gate: State<'_, Arc<crate::migration_gate::MigrationGate>>,
) -> Result<MigrationReport, String> {
    gate.set_ready(false);
    let result = state.storage.start_data_migration().await;
    let ready = state.storage.inspect_data_migration().await.map(|status| status.is_ready()).unwrap_or(false);
    gate.set_ready(ready);
    result
}

#[tauri::command]
pub async fn migration_retry(
    state: State<'_, Arc<AppState>>,
    gate: State<'_, Arc<crate::migration_gate::MigrationGate>>,
) -> Result<MigrationReport, String> {
    migration_start(state, gate).await
}

#[tauri::command]
pub async fn migration_cleanup_backups(state: State<'_, Arc<AppState>>) -> Result<(), String> {
    state.storage.cleanup_migration_backups().await
}

#[tauri::command]
pub async fn webdav_sync_test(state: State<'_, Arc<AppState>>, mut config: WebDavConfig) -> Result<(), String> {
    resolve_webdav_password(&state.storage, &mut config).await?;
    WebDavClient::new(config).test().await
}

#[tauri::command]
pub async fn webdav_password_status(
    state: State<'_, Arc<AppState>>,
    config: WebDavConfig,
) -> Result<WebDavPasswordStatus, String> {
    webdav_saved_password_status(&state.storage, &config).await
}

#[tauri::command]
pub async fn save_webdav_saved_password(
    state: State<'_, Arc<AppState>>,
    config: WebDavConfig,
    password: String,
) -> Result<(), String> {
    save_webdav_password(&state.storage, &config, &password).await
}

#[tauri::command]
pub async fn forget_webdav_saved_password(state: State<'_, Arc<AppState>>, config: WebDavConfig) -> Result<(), String> {
    forget_webdav_password(&state.storage, &config).await
}

#[tauri::command]
pub async fn webdav_sync_secrets_status(state: State<'_, Arc<AppState>>) -> Result<WebDavSyncSecretsStatus, String> {
    core_webdav_sync_secrets_status(&state.storage).await
}

#[tauri::command]
pub async fn save_webdav_sync_secrets_preference(
    state: State<'_, Arc<AppState>>,
    enabled: bool,
    passphrase: Option<String>,
) -> Result<(), String> {
    core_save_webdav_sync_secrets_preference(&state.storage, enabled, passphrase.as_deref()).await
}

#[tauri::command]
pub async fn forget_webdav_sync_secrets_passphrase(state: State<'_, Arc<AppState>>) -> Result<(), String> {
    core_forget_webdav_sync_secrets_passphrase(&state.storage).await
}

#[tauri::command]
pub async fn webdav_sync_upload(
    state: State<'_, Arc<AppState>>,
    mut config: WebDavConfig,
    editor_settings: Option<serde_json::Value>,
    secrets_passphrase: Option<String>,
    include_secrets: bool,
    selection: Option<SyncSelection>,
) -> Result<WebDavSyncSummary, String> {
    resolve_webdav_password(&state.storage, &mut config).await?;
    let explicit_passphrase = secrets_passphrase.as_deref().and_then(|value| {
        let value = value.trim();
        (!value.is_empty()).then_some(value)
    });
    let saved_passphrase = if explicit_passphrase.is_none() {
        resolve_webdav_sync_secrets_passphrase(&state.storage).await?
    } else {
        None
    };
    let passphrase = explicit_passphrase.or(saved_passphrase.as_deref());
    let snapshot = build_sync_snapshot_with_selection(
        &state.storage,
        env!("CARGO_PKG_VERSION"),
        editor_settings,
        SyncExportOptions {
            include_secrets,
            sync_passphrase: passphrase,
            include_ai_secrets: include_secrets,
            include_tunnel_secrets: include_secrets,
            include_plugin_secrets: include_secrets,
        },
        selection.as_ref(),
        Some(&state.plugins),
    )
    .await?;
    WebDavClient::new(config).put_snapshot(&snapshot).await
}

#[tauri::command]
pub async fn webdav_sync_download(
    state: State<'_, Arc<AppState>>,
    mut config: WebDavConfig,
    secrets_passphrase: Option<String>,
    restore_secrets: bool,
    selection: Option<SyncSelection>,
) -> Result<WebDavDownloadResult, String> {
    resolve_webdav_password(&state.storage, &mut config).await?;
    let (snapshot, summary) = WebDavClient::new(config).get_snapshot().await?;
    let explicit_passphrase = secrets_passphrase.as_deref().map(str::trim).filter(|value| !value.is_empty());
    let saved_passphrase = if explicit_passphrase.is_some() {
        None
    } else {
        resolve_webdav_sync_secrets_passphrase(&state.storage).await?
    };
    let apply_summary = apply_sync_snapshot_with_selection(
        &state.storage,
        &snapshot,
        ApplySnapshotOptions {
            secrets_passphrase: explicit_passphrase.or(saved_passphrase.as_deref()),
            restore_secrets,
        },
        selection.as_ref(),
        Some(&state.plugins),
    )
    .await?;
    Ok(WebDavDownloadResult {
        summary,
        editor_settings: state.storage.load_editor_settings().await?,
        desktop_settings: state.storage.load_desktop_settings().await?,
        apply_summary,
    })
}

#[tauri::command]
pub async fn cloud_sync_local_catalog(
    state: State<'_, Arc<AppState>>,
    editor_settings: Option<serde_json::Value>,
) -> Result<SyncSnapshotCatalog, String> {
    describe_local_sync_state(&state.storage, editor_settings, Some(&state.plugins)).await
}

#[tauri::command]
pub async fn webdav_sync_inspect(
    state: State<'_, Arc<AppState>>,
    mut config: WebDavConfig,
    secrets_passphrase: Option<String>,
) -> Result<SyncSnapshotCatalog, String> {
    resolve_webdav_password(&state.storage, &mut config).await?;
    let (snapshot, _) = WebDavClient::new(config).get_snapshot().await?;
    let explicit = secrets_passphrase.as_deref().map(str::trim).filter(|value| !value.is_empty());
    let saved = if explicit.is_none() { resolve_webdav_sync_secrets_passphrase(&state.storage).await? } else { None };
    describe_sync_snapshot(&snapshot, explicit.or(saved.as_deref()))
}

#[tauri::command]
pub async fn snippet_sync_test(state: State<'_, Arc<AppState>>, mut config: SnippetSyncConfig) -> Result<(), String> {
    resolve_snippet_token(&state.storage, &mut config).await?;
    SnippetSyncClient::new(config)?.test().await
}

#[tauri::command]
pub async fn snippet_token_status(
    state: State<'_, Arc<AppState>>,
    config: SnippetSyncConfig,
) -> Result<SnippetTokenStatus, String> {
    snippet_saved_token_status(&state.storage, &config).await
}

#[tauri::command]
pub async fn save_snippet_saved_token(
    state: State<'_, Arc<AppState>>,
    config: SnippetSyncConfig,
    token: String,
) -> Result<(), String> {
    save_snippet_token(&state.storage, &config, &token).await
}

#[tauri::command]
pub async fn forget_snippet_saved_token(
    state: State<'_, Arc<AppState>>,
    config: SnippetSyncConfig,
) -> Result<(), String> {
    forget_snippet_token(&state.storage, &config).await
}

#[tauri::command]
pub async fn snippet_passphrase_status(
    state: State<'_, Arc<AppState>>,
    config: SnippetSyncConfig,
) -> Result<SnippetPassphraseStatus, String> {
    snippet_saved_passphrase_status(&state.storage, &config).await
}

#[tauri::command]
pub async fn save_snippet_saved_passphrase(
    state: State<'_, Arc<AppState>>,
    config: SnippetSyncConfig,
    passphrase: String,
) -> Result<(), String> {
    save_snippet_passphrase(&state.storage, &config, &passphrase).await
}

#[tauri::command]
pub async fn forget_snippet_saved_passphrase(
    state: State<'_, Arc<AppState>>,
    config: SnippetSyncConfig,
) -> Result<(), String> {
    forget_snippet_passphrase(&state.storage, &config).await
}

#[tauri::command]
pub async fn snippet_sync_settings(
    state: State<'_, Arc<AppState>>,
    provider: SnippetProvider,
    instance_url: Option<String>,
) -> Result<SnippetSyncSettings, String> {
    core_snippet_sync_settings(&state.storage, provider, instance_url.as_deref()).await
}

#[tauri::command]
pub async fn save_snippet_sync_id(
    state: State<'_, Arc<AppState>>,
    provider: SnippetProvider,
    instance_url: Option<String>,
    snippet_id: Option<String>,
) -> Result<(), String> {
    core_save_snippet_sync_id(&state.storage, provider, instance_url.as_deref(), snippet_id.as_deref()).await
}

#[tauri::command]
pub async fn retry_snippet_legacy_cleanup(
    state: State<'_, Arc<AppState>>,
    mut config: SnippetSyncConfig,
) -> Result<SnippetSyncSettings, String> {
    resolve_snippet_token(&state.storage, &mut config).await?;
    let provider = config.provider;
    let client = SnippetSyncClient::new(config)?;
    retry_pending_snippet_cleanup(&state.storage, provider, &client).await
}

#[tauri::command]
pub async fn snippet_sync_upload(
    state: State<'_, Arc<AppState>>,
    mut config: SnippetSyncConfig,
    editor_settings: Option<serde_json::Value>,
    snippet_passphrase: Option<String>,
    include_secrets: bool,
    secrets_passphrase: Option<String>,
    selection: Option<SyncSelection>,
    expected_remote_content_hash: Option<String>,
) -> Result<SnippetSyncSummary, String> {
    resolve_snippet_token(&state.storage, &mut config).await?;
    let snippet_passphrase = resolve_snippet_passphrase(&state.storage, &config, snippet_passphrase.as_deref()).await?;
    let secrets_passphrase = if include_secrets {
        Some(
            secrets_passphrase
                .as_deref()
                .map(str::trim)
                .filter(|value| !value.is_empty())
                .ok_or_else(|| "A sync password is required when including synced secrets.".to_string())?,
        )
    } else {
        None
    };
    let snapshot = build_sync_snapshot_with_selection(
        &state.storage,
        env!("CARGO_PKG_VERSION"),
        editor_settings,
        SyncExportOptions {
            include_secrets,
            sync_passphrase: secrets_passphrase,
            include_ai_secrets: include_secrets,
            include_tunnel_secrets: include_secrets,
            include_plugin_secrets: include_secrets,
        },
        selection.as_ref(),
        Some(&state.plugins),
    )
    .await?;
    let client = SnippetSyncClient::new(config)?;
    let mut summary = client
        .put_snapshot_with_expected_remote_hash(
            &snapshot,
            snippet_passphrase.as_deref(),
            secrets_passphrase,
            expected_remote_content_hash.as_deref(),
        )
        .await?;
    finalize_snippet_migration(&state.storage, &client, &mut summary).await?;
    Ok(summary)
}

#[tauri::command]
pub async fn snippet_sync_download(
    state: State<'_, Arc<AppState>>,
    mut config: SnippetSyncConfig,
    snippet_passphrase: Option<String>,
    restore_secrets: bool,
    secrets_passphrase: Option<String>,
    selection: Option<SyncSelection>,
) -> Result<SnippetDownloadResult, String> {
    resolve_snippet_token(&state.storage, &mut config).await?;
    let snippet_passphrase = resolve_snippet_passphrase(&state.storage, &config, snippet_passphrase.as_deref()).await?;
    let (snapshot, summary) = SnippetSyncClient::new(config)?.get_snapshot(snippet_passphrase.as_deref()).await?;
    let apply_summary = apply_sync_snapshot_with_selection(
        &state.storage,
        &snapshot,
        ApplySnapshotOptions { secrets_passphrase: secrets_passphrase.as_deref(), restore_secrets },
        selection.as_ref(),
        Some(&state.plugins),
    )
    .await?;
    Ok(SnippetDownloadResult {
        summary,
        editor_settings: state.storage.load_editor_settings().await?,
        desktop_settings: state.storage.load_desktop_settings().await?,
        apply_summary,
    })
}

#[tauri::command]
pub async fn snippet_sync_inspect(
    state: State<'_, Arc<AppState>>,
    mut config: SnippetSyncConfig,
    snippet_passphrase: Option<String>,
    secrets_passphrase: Option<String>,
) -> Result<SyncSnapshotCatalog, String> {
    resolve_snippet_token(&state.storage, &mut config).await?;
    let snippet_passphrase = resolve_snippet_passphrase(&state.storage, &config, snippet_passphrase.as_deref()).await?;
    let (snapshot, _) = SnippetSyncClient::new(config)?.get_snapshot(snippet_passphrase.as_deref()).await?;
    let explicit = secrets_passphrase.as_deref().map(str::trim).filter(|value| !value.is_empty());
    let saved = if explicit.is_none() { resolve_webdav_sync_secrets_passphrase(&state.storage).await? } else { None };
    describe_sync_snapshot(&snapshot, explicit.or(saved.as_deref()))
}

#[cfg(test)]
mod tests {
    use std::sync::Arc;

    use dbx_core::cloud_sync::SnippetProvider;
    use tauri::Manager;

    use super::AppState;

    #[tokio::test]
    async fn snippet_settings_surfaces_pending_cleanup_after_restart() {
        let dir = std::env::temp_dir().join(format!("dbx-tauri-snippet-cleanup-{}", uuid::Uuid::new_v4()));
        std::fs::create_dir_all(&dir).unwrap();
        let db = dir.join("storage.db");
        let storage = dbx_core::persistence::test_storage::open(&db).await.unwrap();
        storage.save_snippet_migration_state("github", "replacement-id", "legacy-id", "content-hash").await.unwrap();
        drop(storage);

        let storage = dbx_core::persistence::test_storage::open(&db).await.unwrap();
        let app_state = Arc::new(AppState::new_with_plugin_dir(storage, dir.join("plugins")));
        let app = tauri::test::mock_app();
        app.manage(app_state);
        let state: tauri::State<'_, Arc<AppState>> = app.state();
        let settings = super::snippet_sync_settings(state, SnippetProvider::GitHub, None).await.unwrap();

        assert_eq!(settings.snippet_id.as_deref(), Some("replacement-id"));
        assert_eq!(settings.legacy_cleanup_required_id.as_deref(), Some("legacy-id"));
        drop(app);
        std::fs::remove_dir_all(dir).ok();
    }
}