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。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
feat(transfer): persist task run history
jearhe8b30a42b65d8
diff --git a/apps/desktop/src/lib/backend/api.ts b/apps/desktop/src/lib/backend/api.tsindex f5e5c79be7..eb6428f451 100644--- a/apps/desktop/src/lib/backend/api.ts+++ b/apps/desktop/src/lib/backend/api.ts@@ -931,6 +931,9 @@ export const saveHistory = forward("saveHistory");export const loadHistory = forward("loadHistory");export const searchHistory = forward("searchHistory");export const loadHistoryConnectionOptions = forward("loadHistoryConnectionOptions");+export const loadTaskRuns = forward("loadTaskRuns");+export const loadTaskRun = forward("loadTaskRun");+export const loadTaskRunItems = forward("loadTaskRunItems");export const loadRedisHistory = forward("loadRedisHistory");export const clearHistory = forward("clearHistory");export const clearHistoryBySource = forward("clearHistoryBySource");diff --git a/apps/desktop/src/lib/backend/http.ts b/apps/desktop/src/lib/backend/http.tsindex be40d9a9ab..c9fd4bc12d 100644--- a/apps/desktop/src/lib/backend/http.ts+++ b/apps/desktop/src/lib/backend/http.ts@@ -151,6 +151,11 @@ import type {HistorySearchRequest,HistorySearchResult,HistoryConnectionOption,+ TaskRunDetail,+ TaskRunItemsPage,+ TaskRunItemsQuery,+ TaskRunListQuery,+ TaskRunPage,SqlFileRequest,SqlFilePreview,SqlFileTable,@@ -5300,6 +5305,31 @@ export async function loadHistoryConnectionOptions(): Promise<HistoryConnectionOreturn get("/api/history/options");}+export async function loadTaskRuns(query: TaskRunListQuery = {}): Promise<TaskRunPage> {+ return get(+ `/api/task-runs?${qs({+ limit: query.limit,+ cursorCreatedAt: query.cursor?.createdAt,+ cursorRunId: query.cursor?.runId,+ taskType: query.taskType,+ status: query.status,+ })}`,+ );+}++export async function loadTaskRun(runId: string): Promise<TaskRunDetail | null> {+ return get(`/api/task-runs/${encodeURIComponent(runId)}`);+}++export async function loadTaskRunItems(runId: string, query: TaskRunItemsQuery = {}): Promise<TaskRunItemsPage> {+ return get(+ `/api/task-runs/${encodeURIComponent(runId)}/items?${qs({+ limit: query.limit,+ afterItemIndex: query.afterItemIndex,+ })}`,+ );+}+export async function loadRedisHistory(limit = 100, offset = 0): Promise<HistoryEntry[]> {return loadHistory(limit, offset, "redis_command");}diff --git a/apps/desktop/src/lib/backend/tauri.ts b/apps/desktop/src/lib/backend/tauri.tsindex ecb3f5f4be..bf5861cbb8 100644--- a/apps/desktop/src/lib/backend/tauri.ts+++ b/apps/desktop/src/lib/backend/tauri.ts@@ -5364,6 +5364,115 @@ export interface HistoryConnectionOption extends HistoryConnectionFilter {databases: string[];}+export type TaskType = "transfer";+export type TaskLifecycleOwner = "tauri" | "web";+export type TaskRunStatus = "running" | "succeeded" | "partial_failed" | "failed" | "cancelled";+export type TaskItemKind = "table" | "view" | "materialized_view" | "procedure" | "function" | "trigger" | "sequence" | "event" | "object";+export type TaskItemStatus = "pending" | "running" | "succeeded" | "skipped" | "failed" | "cancelled" | "not_started" | "incomplete";+export type TaskRowCountState = "not_applicable" | "known" | "unknown" | "incomplete";+export type TransferRunContent = "structure_and_data" | "structure_only" | "data_only";+export type TransferRunMode = "append" | "overwrite" | "upsert";+export type TransferRunObjectSelectionMode = "unspecified" | "explicit";++export interface TaskEndpointSnapshot {+ connectionId: string;+ databaseType: string;+ database: string;+ schema: string;+ catalog?: string | null;+}++export interface TaskRun {+ runId: string;+ taskType: TaskType;+ lifecycleOwner: TaskLifecycleOwner;+ status: TaskRunStatus;+ createdAt: string;+ startedAt: string;+ finishedAt?: string | null;+ ownerInstanceId: string;+ errorCode?: string | null;+ safeErrorSummary?: string | null;+ historyComplete: boolean;+ source: TaskEndpointSnapshot;+ target: TaskEndpointSnapshot;+}++export interface TransferRunDetails {+ runId: string;+ content: TransferRunContent;+ mode: TransferRunMode;+ batchSize: number;+ createTable: boolean;+ dropTargetBeforeCreate: boolean;+ targetTableNameCase: "preserve" | "lower" | "upper";+ quoteTargetColumnNames: boolean;+ ownershipPolicy: "preserve" | "skip" | "reassign_missing";+ filteredTableCount: number;+ tableTotal: number;+ objectSelectionMode: TransferRunObjectSelectionMode;+ selectedObjectCount?: number | null;+}++export interface TaskRunDetail {+ run: TaskRun;+ transfer?: TransferRunDetails | null;+}++export interface TaskRunCursor {+ createdAt: string;+ runId: string;+}++export interface TaskRunListQuery {+ limit?: number;+ cursor?: TaskRunCursor | null;+ taskType?: TaskType;+ status?: TaskRunStatus;+}++export interface TaskRunPage {+ items: TaskRun[];+ nextCursor?: TaskRunCursor | null;+}++export interface TaskRunItem {+ runId: string;+ itemIndex: number;+ itemKind: TaskItemKind;+ sourceObject: string;+ targetObject: string;+ status: TaskItemStatus;+ sourceRowCount?: number | null;+ movedRowCount?: number | null;+ targetRowCount?: number | null;+ rowCountState: TaskRowCountState;+ hasTableFilter: boolean;+ safeErrorSummary?: string | null;+}++export interface TaskRunItemsQuery {+ limit?: number;+ afterItemIndex?: number;+}++export interface TaskRunItemsPage {+ items: TaskRunItem[];+ nextAfterItemIndex?: number | null;+}++export async function loadTaskRuns(query: TaskRunListQuery = {}): Promise<TaskRunPage> {+ return invoke("load_task_runs", { query });+}++export async function loadTaskRun(runId: string): Promise<TaskRunDetail | null> {+ return invoke("load_task_run", { runId });+}++export async function loadTaskRunItems(runId: string, query: TaskRunItemsQuery = {}): Promise<TaskRunItemsPage> {+ return invoke("load_task_run_items", { runId, query });+}+export async function saveHistory(entry: HistoryEntry): Promise<void> {return invoke("save_history", { entry });}diff --git a/crates/dbx-core/src/data/transfer.rs b/crates/dbx-core/src/data/transfer.rsindex b45c6205a3..7c68d060d6 100644--- a/crates/dbx-core/src/data/transfer.rs+++ b/crates/dbx-core/src/data/transfer.rs@@ -485,6 +485,13 @@ impl TransferRequest {}}+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub struct TransferTableResult {+ pub moved_rows: u64,+ /// Source COUNT result when the executor obtained it. It is not a target row count.+ pub source_row_count: Option<u64>,+}+#[derive(Debug, Clone, Serialize)]#[serde(rename_all = "camelCase")]pub struct TransferProgress {@@ -10516,15 +10523,16 @@ async fn create_transfer_target_table(Ok(())}-/// Transfer a single table. Returns rows transferred.-/// `progress_callback` is invoked for progress updates.+/// Transfer a single table, returning moved rows and the source COUNT when available.+/// `progress_callback` is invoked for progress updates; source-count observation is separate+/// so the existing progress event payload remains unchanged.////// `preexisting_backup_names` carries the output of [`rename_tables_to_backup`] and is/// required whenever `drop_target_before_create` is set — this pass only checks whether the/// table was renamed aside, and never renames or drops anything itself. Removing the backups/// is [`drop_backup_tables`], after every table has succeeded.#[allow(clippy::too_many_arguments)]-async fn transfer_table_inner<F>(+async fn transfer_table_inner<F, C>(state: &Arc<AppState>,request: &TransferRequest,table: &str,@@ -10537,14 +10545,17 @@ async fn transfer_table_inner<F>(pending_fk_alters: &mut Vec<(String, String)>,preexisting_backup_names: Option<&HashMap<String, String>>,mut progress_callback: F,-) -> Result<u64, String>+ mut source_count_callback: C,+) -> Result<TransferTableResult, String>whereF: FnMut(TransferProgress),+ C: FnMut(Option<u64>),{if *target_db_type == DatabaseType::Db2 {db2::validate_request(request)?;}if is_mongodb_transfer_type(source_db_type) || is_mongodb_transfer_type(target_db_type) {+ source_count_callback(None);return transfer_mongodb_table(state,request,@@ -10556,7 +10567,8 @@ wheretarget_pool_key,progress_callback,)- .await;+ .await+ .map(|moved_rows| TransferTableResult { moved_rows, source_row_count: None });}let table_filter = transfer_table_filter_for(request, table)?;@@ -10762,6 +10774,7 @@ where} else {None};+ source_count_callback(total_rows);log::info!("[transfer] {} total_rows={:?}", table, total_rows);let server_side_complex_copy =@@ -10847,7 +10860,7 @@ where).await?;}- return Ok(0);+ return Ok(TransferTableResult { moved_rows: 0, source_row_count: None });}// A preexisting target also needs its columns read, even for a data-only@@ -11032,7 +11045,7 @@ whereerror: None,terminal: false,});- return Ok(copied);+ return Ok(TransferTableResult { moved_rows: copied, source_row_count: total_rows });}// COPY fast path: PG-family append/overwrite transfers stream the whole@@ -11394,7 +11407,7 @@ where.await?;}- Ok(total_transferred)+ Ok(TransferTableResult { moved_rows: total_transferred, source_row_count: total_rows })}/// Free the constraint names the backups are still holding (MySQL family).@@ -11705,10 +11718,49 @@ pub async fn transfer_table<F>(known_foreign_keys: &HashMap<String, Vec<db::ForeignKeyInfo>>,pending_fk_alters: &mut Vec<(String, String)>,preexisting_backup_names: Option<&HashMap<String, String>>,- mut progress_callback: F,+ progress_callback: F,) -> Result<u64, String>whereF: FnMut(TransferProgress),+{+ transfer_table_with_result(+ state,+ request,+ table,+ table_index,+ source_db_type,+ target_db_type,+ source_pool_key,+ target_pool_key,+ known_foreign_keys,+ pending_fk_alters,+ preexisting_backup_names,+ progress_callback,+ |_| {},+ )+ .await+ .map(|result| result.moved_rows)+}++#[allow(clippy::too_many_arguments)]+pub async fn transfer_table_with_result<F, C>(+ state: &Arc<AppState>,+ request: &TransferRequest,+ table: &str,+ table_index: usize,+ source_db_type: &DatabaseType,+ target_db_type: &DatabaseType,+ source_pool_key: &str,+ target_pool_key: &str,+ known_foreign_keys: &HashMap<String, Vec<db::ForeignKeyInfo>>,+ pending_fk_alters: &mut Vec<(String, String)>,+ preexisting_backup_names: Option<&HashMap<String, String>>,+ mut progress_callback: F,+ mut source_count_callback: C,+) -> Result<TransferTableResult, String>+where+ F: FnMut(TransferProgress),+ C: FnMut(Option<u64>),{let state = state.clone();let request = request.clone();@@ -11731,6 +11783,7 @@ wherelet request_target_schema = request.target_schema.clone();let request_target_catalog = request.target_catalog.clone();let (progress_tx, mut progress_rx) = tokio::sync::mpsc::channel(TRANSFER_PROGRESS_CHANNEL_CAPACITY);+ let (source_count_tx, mut source_count_rx) = tokio::sync::mpsc::channel(1);let mut task = tokio::spawn(async move {let mut task_pending_fk_alters = Vec::new();@@ -11749,6 +11802,9 @@ wheremove |progress| {try_send_transfer_progress(&progress_tx, progress);},+ move |source_count| {+ let _ = source_count_tx.try_send(source_count);+ },).await;(result, task_pending_fk_alters)@@ -11759,6 +11815,7 @@ wheretokio::select! {biased;Some(progress) = progress_rx.recv() => progress_callback(progress),+ Some(source_count) = source_count_rx.recv() => source_count_callback(source_count),result = &mut task => {let (result, task_pending_fk_alters) =result.map_err(|error| format!("Transfer table task failed: {error}"))?;diff --git a/crates/dbx-core/src/data/transfer/iris_tests.rs b/crates/dbx-core/src/data/transfer/iris_tests.rsindex 08117748de..5cb8217ae2 100644--- a/crates/dbx-core/src/data/transfer/iris_tests.rs+++ b/crates/dbx-core/src/data/transfer/iris_tests.rs@@ -310,6 +310,7 @@ async fn iris_transfer_agent_preserves_errors_count_fallback_and_cancellation()for failure in ["source", "target", "count", "cancel"] {let (directory, state, request, source, target) = iris_transfer_fixture(None, 5, failure, true).await;let mut totals = Vec::new();+ let mut observed_source_count = None;let result = Box::pin(transfer_table_inner(&state,&request,@@ -328,12 +329,16 @@ async fn iris_transfer_agent_preserves_errors_count_fallback_and_cancellation()CANCELLED.try_write().unwrap().insert(request.transfer_id.clone());}},+ |source_count| observed_source_count = source_count,)).await;clear_cancelled(&request.transfer_id).await;state.shutdown(std::time::Duration::from_secs(1)).await;if failure == "count" {- assert_eq!(result.unwrap(), 5);+ let result = result.unwrap();+ assert_eq!(result.moved_rows, 5);+ assert_eq!(result.source_row_count, None);+ assert_eq!(observed_source_count, None);assert!(totals.iter().all(Option::is_none));} else {let error = result.unwrap_err();diff --git a/crates/dbx-core/src/persistence/mod.rs b/crates/dbx-core/src/persistence/mod.rsindex 42ff8df5a8..d8cc71d266 100644--- a/crates/dbx-core/src/persistence/mod.rs+++ b/crates/dbx-core/src/persistence/mod.rs@@ -5,5 +5,6 @@ pub mod saved_sql;pub mod secret_codec;pub mod state_persistence;pub mod storage;+pub mod task_history;#[cfg(any(test, feature = "test-support"))]pub mod test_storage;diff --git a/crates/dbx-core/src/persistence/storage.rs b/crates/dbx-core/src/persistence/storage.rsindex ceb08a4e33..e838508907 100644--- a/crates/dbx-core/src/persistence/storage.rs+++ b/crates/dbx-core/src/persistence/storage.rs@@ -37,6 +37,12 @@ use crate::models::connection::{ConnectionConfig, DatabaseConnectionInfo, Databause crate::persistence::secret_codec::{key_file_candidates, SecretCodec, SecretKeyPolicy, SecretKeyResolution, SecretKeySource,};+use crate::persistence::task_history::{+ RowCountState, TaskEndpointSnapshot, TaskHistoryStorageError, TaskItemKind, TaskItemStatus, TaskLifecycleOwner,+ TaskRun, TaskRunCursor, TaskRunDetail, TaskRunItem, TaskRunItemsPage, TaskRunItemsQuery, TaskRunListQuery,+ TaskRunPage, TaskRunStatus, TaskType, TransferObjectSelectionMode, TransferRunContent, TransferRunDetails,+ TransferRunMode, TransferRunOwnershipPolicy, TransferRunTargetTableNameCase,+};use crate::prompt_template::PromptTemplate;use crate::saved_sql::{SavedSqlFile, SavedSqlFolder, SavedSqlLibrary};@@ -83,6 +89,9 @@ const USER_DATA_TABLES: &[&str] = &["connections","connection_secrets","history",+ "task_runs",+ "transfer_run_details",+ "task_run_items","ai_config","ai_provider_configs","ai_conversations",@@ -1044,6 +1053,62 @@ const SCHEMA_STATEMENTS: &[&str] = &[,mcp_response_json TEXT,mcp_session_id TEXT)",+ "CREATE TABLE IF NOT EXISTS task_runs (+ run_id TEXT PRIMARY KEY NOT NULL,+ task_type TEXT NOT NULL,+ lifecycle_owner TEXT NOT NULL,+ status TEXT NOT NULL,+ created_at TEXT NOT NULL,+ started_at TEXT NOT NULL,+ finished_at TEXT,+ owner_instance_id TEXT NOT NULL,+ error_code TEXT,+ safe_error_summary TEXT,+ history_complete INTEGER NOT NULL DEFAULT 0,+ source_connection_id TEXT NOT NULL,+ source_database_type TEXT NOT NULL,+ source_database TEXT NOT NULL,+ source_schema TEXT NOT NULL,+ source_catalog TEXT,+ target_connection_id TEXT NOT NULL,+ target_database_type TEXT NOT NULL,+ target_database TEXT NOT NULL,+ target_schema TEXT NOT NULL,+ target_catalog TEXT+ )",+ "CREATE INDEX IF NOT EXISTS idx_task_runs_created ON task_runs(created_at DESC, run_id DESC)",+ "CREATE INDEX IF NOT EXISTS idx_task_runs_type_status_created ON task_runs(task_type, status, created_at DESC, run_id DESC)",+ "CREATE TABLE IF NOT EXISTS transfer_run_details (+ run_id TEXT PRIMARY KEY NOT NULL,+ content TEXT NOT NULL,+ mode TEXT NOT NULL,+ batch_size INTEGER NOT NULL,+ create_table INTEGER NOT NULL,+ drop_target_before_create INTEGER NOT NULL,+ target_table_name_case TEXT NOT NULL,+ quote_target_column_names INTEGER NOT NULL,+ ownership_policy TEXT NOT NULL,+ filtered_table_count INTEGER NOT NULL,+ table_total INTEGER NOT NULL,+ object_selection_mode TEXT NOT NULL,+ selected_object_count INTEGER+ )",+ "CREATE TABLE IF NOT EXISTS task_run_items (+ run_id TEXT NOT NULL,+ item_index INTEGER NOT NULL,+ item_kind TEXT NOT NULL,+ source_object TEXT NOT NULL,+ target_object TEXT NOT NULL,+ status TEXT NOT NULL,+ source_row_count INTEGER,+ moved_row_count INTEGER,+ target_row_count INTEGER,+ row_count_state TEXT NOT NULL,+ has_table_filter INTEGER NOT NULL DEFAULT 0,+ safe_error_summary TEXT,+ PRIMARY KEY (run_id, item_index)+ )",+ "CREATE INDEX IF NOT EXISTS idx_task_run_items_run_status ON task_run_items(run_id, status, item_index)","CREATE TABLE IF NOT EXISTS ai_config (id INTEGER PRIMARY KEY CHECK (id = 1),config_json TEXT NOT NULL@@ -3836,6 +3901,475 @@ impl Storage {}}+impl Storage {+ pub async fn create_task_run(+ &self,+ run: &TaskRun,+ details: &TransferRunDetails,+ items: &[TaskRunItem],+ ) -> Result<(), TaskHistoryStorageError> {+ let run = run.clone();+ let details = details.clone();+ let items = items.to_vec();+ let inserted = self+ .with_conn(move |conn| {+ let tx = conn+ .transaction_with_behavior(TransactionBehavior::Immediate)+ .map_err(|error| error.to_string())?;+ let exists = tx+ .query_row("SELECT 1 FROM task_runs WHERE run_id = ?1", [&run.run_id], |row| row.get::<_, i64>(0))+ .optional()+ .map_err(|error| error.to_string())?+ .is_some();+ if exists {+ return Ok(false);+ }+ tx.execute(+ "INSERT INTO task_runs (+ run_id, task_type, lifecycle_owner, status, created_at, started_at, finished_at,+ owner_instance_id, error_code, safe_error_summary, history_complete,+ source_connection_id, source_database_type, source_database, source_schema, source_catalog,+ target_connection_id, target_database_type, target_database, target_schema, target_catalog+ ) VALUES (+ ?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11,+ ?12, ?13, ?14, ?15, ?16, ?17, ?18, ?19, ?20, ?21+ )",+ params![+ run.run_id,+ run.task_type.as_storage_str(),+ run.lifecycle_owner.as_storage_str(),+ run.status.as_storage_str(),+ run.created_at,+ run.started_at,+ run.finished_at,+ run.owner_instance_id,+ run.error_code,+ run.safe_error_summary,+ run.history_complete,+ run.source.connection_id,+ run.source.database_type,+ run.source.database,+ run.source.schema,+ run.source.catalog,+ run.target.connection_id,+ run.target.database_type,+ run.target.database,+ run.target.schema,+ run.target.catalog,+ ],+ )+ .map_err(|error| error.to_string())?;+ tx.execute(+ "INSERT INTO transfer_run_details (+ run_id, content, mode, batch_size, create_table, drop_target_before_create,+ target_table_name_case, quote_target_column_names, ownership_policy,+ filtered_table_count, table_total, object_selection_mode, selected_object_count+ ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12, ?13)",+ params![+ details.run_id,+ details.content.as_storage_str(),+ details.mode.as_storage_str(),+ details.batch_size,+ details.create_table,+ details.drop_target_before_create,+ details.target_table_name_case.as_storage_str(),+ details.quote_target_column_names,+ details.ownership_policy.as_storage_str(),+ details.filtered_table_count,+ details.table_total,+ details.object_selection_mode.as_storage_str(),+ details.selected_object_count,+ ],+ )+ .map_err(|error| error.to_string())?;+ for item in items {+ insert_task_run_item(&tx, &item)?;+ }+ tx.commit().map_err(|error| error.to_string())?;+ Ok(true)+ })+ .await+ .map_err(|_| TaskHistoryStorageError::StorageUnavailable)?;+ if inserted {+ Ok(())+ } else {+ Err(TaskHistoryStorageError::RunIdConflict)+ }+ }++ pub async fn save_task_run_item(&self, item: &TaskRunItem) -> Result<bool, TaskHistoryStorageError> {+ let item = item.clone();+ self.with_conn(move |conn| {+ let tx = conn+ .transaction_with_behavior(TransactionBehavior::Immediate)+ .map_err(|error| error.to_string())?;+ let run_status = tx+ .query_row("SELECT status FROM task_runs WHERE run_id = ?1", [&item.run_id], |row| {+ row.get::<_, String>(0)+ })+ .optional()+ .map_err(|error| error.to_string())?;+ if run_status.as_deref() != Some("running") {+ return Ok(false);+ }+ let changed = tx+ .execute(+ "INSERT INTO task_run_items (+ run_id, item_index, item_kind, source_object, target_object, status,+ source_row_count, moved_row_count, target_row_count, row_count_state,+ has_table_filter, safe_error_summary+ ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12)+ ON CONFLICT(run_id, item_index) DO UPDATE SET+ item_kind = excluded.item_kind,+ source_object = excluded.source_object,+ target_object = excluded.target_object,+ status = excluded.status,+ source_row_count = excluded.source_row_count,+ moved_row_count = excluded.moved_row_count,+ target_row_count = excluded.target_row_count,+ row_count_state = excluded.row_count_state,+ has_table_filter = excluded.has_table_filter,+ safe_error_summary = excluded.safe_error_summary+ WHERE task_run_items.status NOT IN ('succeeded', 'skipped', 'failed', 'cancelled', 'not_started', 'incomplete')",+ params![+ item.run_id,+ item.item_index,+ item.item_kind.as_storage_str(),+ item.source_object,+ item.target_object,+ item.status.as_storage_str(),+ item.source_row_count,+ item.moved_row_count,+ item.target_row_count,+ item.row_count_state.as_storage_str(),+ item.has_table_filter,+ item.safe_error_summary,+ ],+ )+ .map_err(|error| error.to_string())?;+ tx.commit().map_err(|error| error.to_string())?;+ Ok(changed > 0)+ })+ .await+ .map_err(|_| TaskHistoryStorageError::StorageUnavailable)+ }++ pub async fn finish_task_run(+ &self,+ run_id: &str,+ status: TaskRunStatus,+ error_code: Option<&str>,+ safe_error_summary: Option<&str>,+ history_complete: bool,+ ) -> Result<bool, TaskHistoryStorageError> {+ let run_id = run_id.to_string();+ let error_code = error_code.map(str::to_string);+ let safe_error_summary = safe_error_summary.map(str::to_string);+ self.with_conn(move |conn| {+ let tx = conn+ .transaction_with_behavior(TransactionBehavior::Immediate)+ .map_err(|error| error.to_string())?;+ let current = tx+ .query_row("SELECT status FROM task_runs WHERE run_id = ?1", [&run_id], |row| {+ row.get::<_, String>(0)+ })+ .optional()+ .map_err(|error| error.to_string())?;+ let Some(current) = current else {+ return Err("Task run does not exist".to_string());+ };+ if current != "running" {+ return Ok(false);+ }+ if !status.is_terminal() {+ return Err("A task run cannot be finished with a running status".to_string());+ }+ let finished_at = chrono::Utc::now().to_rfc3339_opts(chrono::SecondsFormat::Millis, true);+ let changed = tx+ .execute(+ "UPDATE task_runs SET status = ?2, finished_at = ?3, error_code = ?4,+ safe_error_summary = ?5, history_complete = ?6 WHERE run_id = ?1 AND status = 'running'",+ params![run_id, status.as_storage_str(), finished_at, error_code, safe_error_summary, history_complete],+ )+ .map_err(|error| error.to_string())?;+ if changed == 0 {+ return Ok(false);+ }+ tx.execute(+ "UPDATE task_run_items SET status = 'not_started'+ WHERE run_id = ?1 AND status = 'pending'",+ [&run_id],+ )+ .map_err(|error| error.to_string())?;+ tx.execute(+ "UPDATE task_run_items SET status = 'incomplete',+ row_count_state = CASE WHEN row_count_state = 'not_applicable' THEN row_count_state ELSE 'incomplete' END,+ safe_error_summary = COALESCE(safe_error_summary, ?2)+ WHERE run_id = ?1 AND status = 'running'",+ params![run_id, "Transfer item did not complete."],+ )+ .map_err(|error| error.to_string())?;+ tx.commit().map_err(|error| error.to_string())?;+ Ok(true)+ })+ .await+ .map_err(|_| TaskHistoryStorageError::StorageUnavailable)+ }++ pub async fn get_task_run_detail(&self, run_id: &str) -> Result<Option<TaskRunDetail>, TaskHistoryStorageError> {+ let run_id = run_id.to_string();+ self.with_conn(move |conn| {+ let run = conn+ .query_row(+ "SELECT run_id, task_type, lifecycle_owner, status, created_at, started_at, finished_at,+ owner_instance_id, error_code, safe_error_summary, history_complete,+ source_connection_id, source_database_type, source_database, source_schema, source_catalog,+ target_connection_id, target_database_type, target_database, target_schema, target_catalog+ FROM task_runs WHERE run_id = ?1",+ [&run_id],+ map_task_run_row,+ )+ .optional()+ .map_err(|error| error.to_string())?;+ let Some(run) = run else {+ return Ok(None);+ };+ let transfer = conn+ .query_row(+ "SELECT run_id, content, mode, batch_size, create_table, drop_target_before_create,+ target_table_name_case, quote_target_column_names, ownership_policy,+ filtered_table_count, table_total, object_selection_mode, selected_object_count+ FROM transfer_run_details WHERE run_id = ?1",+ [&run_id],+ map_transfer_run_details_row,+ )+ .optional()+ .map_err(|error| error.to_string())?;+ Ok(Some(TaskRunDetail { run, transfer }))+ })+ .await+ .map_err(|_| TaskHistoryStorageError::StorageUnavailable)+ }++ pub async fn list_task_runs(&self, query: TaskRunListQuery) -> Result<TaskRunPage, TaskHistoryStorageError> {+ self.with_conn(move |conn| {+ let limit = query.limit.filter(|limit| *limit > 0).unwrap_or(50).clamp(1, 100);+ let mut predicates = Vec::new();+ let mut values = Vec::<Value>::new();+ if let Some(task_type) = query.task_type {+ predicates.push("task_type = ?".to_string());+ values.push(Value::Text(task_type.as_storage_str().to_string()));+ }+ if let Some(status) = query.status {+ predicates.push("status = ?".to_string());+ values.push(Value::Text(status.as_storage_str().to_string()));+ }+ if let Some(cursor) = query.cursor {+ predicates.push("(created_at < ? OR (created_at = ? AND run_id < ?))".to_string());+ values.push(Value::Text(cursor.created_at.clone()));+ values.push(Value::Text(cursor.created_at));+ values.push(Value::Text(cursor.run_id));+ }+ let where_clause =+ if predicates.is_empty() { String::new() } else { format!(" WHERE {}", predicates.join(" AND ")) };+ let sql = format!(+ "SELECT run_id, task_type, lifecycle_owner, status, created_at, started_at, finished_at,+ owner_instance_id, error_code, safe_error_summary, history_complete,+ source_connection_id, source_database_type, source_database, source_schema, source_catalog,+ target_connection_id, target_database_type, target_database, target_schema, target_catalog+ FROM task_runs{where_clause} ORDER BY created_at DESC, run_id DESC LIMIT ?"+ );+ values.push(Value::Integer((limit + 1) as i64));+ let mut stmt = conn.prepare(&sql).map_err(|error| error.to_string())?;+ let rows =+ stmt.query_map(params_from_iter(values.iter()), map_task_run_row).map_err(|error| error.to_string())?;+ let mut items = rows.collect::<Result<Vec<_>, _>>().map_err(|error| error.to_string())?;+ let has_more = items.len() > limit;+ items.truncate(limit);+ let next_cursor = if has_more {+ items.last().map(|run| TaskRunCursor { created_at: run.created_at.clone(), run_id: run.run_id.clone() })+ } else {+ None+ };+ Ok(TaskRunPage { items, next_cursor })+ })+ .await+ .map_err(|_| TaskHistoryStorageError::StorageUnavailable)+ }++ pub async fn list_task_run_items(+ &self,+ run_id: &str,+ query: TaskRunItemsQuery,+ ) -> Result<TaskRunItemsPage, TaskHistoryStorageError> {+ let run_id = run_id.to_string();+ self.with_conn(move |conn| {+ let limit = query.limit.filter(|limit| *limit > 0).unwrap_or(100).clamp(1, 200);+ let after = query.after_item_index.unwrap_or(-1);+ let mut stmt = conn+ .prepare(+ "SELECT run_id, item_index, item_kind, source_object, target_object, status,+ source_row_count, moved_row_count, target_row_count, row_count_state,+ has_table_filter, safe_error_summary+ FROM task_run_items WHERE run_id = ?1 AND item_index > ?2+ ORDER BY item_index ASC LIMIT ?3",+ )+ .map_err(|error| error.to_string())?;+ let rows = stmt+ .query_map(params![run_id, after, (limit + 1) as i64], map_task_run_item_row)+ .map_err(|error| error.to_string())?;+ let mut items = rows.collect::<Result<Vec<_>, _>>().map_err(|error| error.to_string())?;+ let has_more = items.len() > limit;+ items.truncate(limit);+ let next_after_item_index = if has_more { items.last().map(|item| item.item_index) } else { None };+ Ok(TaskRunItemsPage { items, next_after_item_index })+ })+ .await+ .map_err(|_| TaskHistoryStorageError::StorageUnavailable)+ }++ pub async fn delete_task_run(&self, run_id: &str) -> Result<bool, TaskHistoryStorageError> {+ const RUNNING_SENTINEL: &str = "TASK_RUN_STILL_RUNNING";+ let run_id = run_id.to_string();+ let result = self+ .with_conn(move |conn| {+ let tx = conn+ .transaction_with_behavior(TransactionBehavior::Immediate)+ .map_err(|error| error.to_string())?;+ let current = tx+ .query_row("SELECT status FROM task_runs WHERE run_id = ?1", [&run_id], |row| {+ row.get::<_, String>(0)+ })+ .optional()+ .map_err(|error| error.to_string())?;+ let Some(current) = current else {+ return Ok(false);+ };+ if TaskRunStatus::from_storage(¤t).is_none_or(|status| !status.is_terminal()) {+ return Err(RUNNING_SENTINEL.to_string());+ }+ tx.execute("DELETE FROM task_run_items WHERE run_id = ?1", [&run_id])+ .map_err(|error| error.to_string())?;+ tx.execute("DELETE FROM transfer_run_details WHERE run_id = ?1", [&run_id])+ .map_err(|error| error.to_string())?;+ tx.execute("DELETE FROM task_runs WHERE run_id = ?1", [&run_id]).map_err(|error| error.to_string())?;+ tx.commit().map_err(|error| error.to_string())?;+ Ok(true)+ })+ .await;+ match result {+ Ok(deleted) => Ok(deleted),+ Err(error) if error == RUNNING_SENTINEL => Err(TaskHistoryStorageError::RunStillRunning),+ Err(_) => Err(TaskHistoryStorageError::StorageUnavailable),+ }+ }+}++fn insert_task_run_item(tx: &rusqlite::Transaction<'_>, item: &TaskRunItem) -> Result<(), String> {+ tx.execute(+ "INSERT INTO task_run_items (+ run_id, item_index, item_kind, source_object, target_object, status,+ source_row_count, moved_row_count, target_row_count, row_count_state,+ has_table_filter, safe_error_summary+ ) VALUES (?1, ?2, ?3, ?4, ?5, ?6, ?7, ?8, ?9, ?10, ?11, ?12)",+ params![+ item.run_id,+ item.item_index,+ item.item_kind.as_storage_str(),+ item.source_object,+ item.target_object,+ item.status.as_storage_str(),+ item.source_row_count,+ item.moved_row_count,+ item.target_row_count,+ item.row_count_state.as_storage_str(),+ item.has_table_filter,+ item.safe_error_summary,+ ],+ )+ .map(|_| ())+ .map_err(|error| error.to_string())+}++fn map_task_run_row(row: &rusqlite::Row<'_>) -> rusqlite::Result<TaskRun> {+ let task_type: String = row.get(1)?;+ let lifecycle_owner: String = row.get(2)?;+ let status: String = row.get(3)?;+ Ok(TaskRun {+ run_id: row.get(0)?,+ task_type: TaskType::from_storage(&task_type).ok_or(rusqlite::Error::InvalidQuery)?,+ lifecycle_owner: TaskLifecycleOwner::from_storage(&lifecycle_owner).ok_or(rusqlite::Error::InvalidQuery)?,+ status: TaskRunStatus::from_storage(&status).ok_or(rusqlite::Error::InvalidQuery)?,+ created_at: row.get(4)?,+ started_at: row.get(5)?,+ finished_at: row.get(6)?,+ owner_instance_id: row.get(7)?,+ error_code: row.get(8)?,+ safe_error_summary: row.get(9)?,+ history_complete: row.get(10)?,+ source: TaskEndpointSnapshot {+ connection_id: row.get(11)?,+ database_type: row.get(12)?,+ database: row.get(13)?,+ schema: row.get(14)?,+ catalog: row.get(15)?,+ },+ target: TaskEndpointSnapshot {+ connection_id: row.get(16)?,+ database_type: row.get(17)?,+ database: row.get(18)?,+ schema: row.get(19)?,+ catalog: row.get(20)?,+ },+ })+}++fn map_transfer_run_details_row(row: &rusqlite::Row<'_>) -> rusqlite::Result<TransferRunDetails> {+ let content: String = row.get(1)?;+ let mode: String = row.get(2)?;+ let table_name_case: String = row.get(6)?;+ let ownership_policy: String = row.get(8)?;+ let selection_mode: String = row.get(11)?;+ Ok(TransferRunDetails {+ run_id: row.get(0)?,+ content: TransferRunContent::from_storage(&content).ok_or(rusqlite::Error::InvalidQuery)?,+ mode: TransferRunMode::from_storage(&mode).ok_or(rusqlite::Error::InvalidQuery)?,+ batch_size: row.get(3)?,+ create_table: row.get(4)?,+ drop_target_before_create: row.get(5)?,+ target_table_name_case: TransferRunTargetTableNameCase::from_storage(&table_name_case)+ .ok_or(rusqlite::Error::InvalidQuery)?,+ quote_target_column_names: row.get(7)?,+ ownership_policy: TransferRunOwnershipPolicy::from_storage(&ownership_policy)+ .ok_or(rusqlite::Error::InvalidQuery)?,+ filtered_table_count: row.get(9)?,+ table_total: row.get(10)?,+ object_selection_mode: TransferObjectSelectionMode::from_storage(&selection_mode)+ .ok_or(rusqlite::Error::InvalidQuery)?,+ selected_object_count: row.get(12)?,+ })+}++fn map_task_run_item_row(row: &rusqlite::Row<'_>) -> rusqlite::Result<TaskRunItem> {+ let item_kind: String = row.get(2)?;+ let status: String = row.get(5)?;+ let row_count_state: String = row.get(9)?;+ Ok(TaskRunItem {+ run_id: row.get(0)?,+ item_index: row.get(1)?,+ item_kind: TaskItemKind::from_storage(&item_kind).ok_or(rusqlite::Error::InvalidQuery)?,+ source_object: row.get(3)?,+ target_object: row.get(4)?,+ status: TaskItemStatus::from_storage(&status).ok_or(rusqlite::Error::InvalidQuery)?,+ source_row_count: row.get(6)?,+ moved_row_count: row.get(7)?,+ target_row_count: row.get(8)?,+ row_count_state: RowCountState::from_storage(&row_count_state).ok_or(rusqlite::Error::InvalidQuery)?,+ has_table_filter: row.get(10)?,+ safe_error_summary: row.get(11)?,+ })+}+// AI Configfn ai_provider_key(provider: &AiProvider) -> String {@@ -14243,4 +14777,133 @@ mod tests {.unwrap();assert_eq!(storage.stored_connection_count().await.unwrap(), None);}++ #[tokio::test]+ async fn task_run_storage_is_idempotent_paginated_and_deletes_only_terminal_runs() {+ use crate::persistence::task_history::{+ RowCountState, TaskEndpointSnapshot, TaskHistoryStorageError, TaskItemKind, TaskItemStatus,+ TaskLifecycleOwner, TaskRun, TaskRunItem, TaskRunItemsQuery, TaskRunListQuery, TaskRunStatus, TaskType,+ TransferObjectSelectionMode, TransferRunContent, TransferRunDetails, TransferRunMode,+ TransferRunOwnershipPolicy, TransferRunTargetTableNameCase,+ };++ let dir = tempfile::tempdir().unwrap();+ let path = dir.path().join("dbx.db");+ let storage = crate::persistence::test_storage::open_unmigrated(&path).await.unwrap();+ let run = TaskRun {+ run_id: "history-storage-run".to_string(),+ task_type: TaskType::Transfer,+ lifecycle_owner: TaskLifecycleOwner::Web,+ status: TaskRunStatus::Running,+ created_at: "2025-01-01T00:00:00.000Z".to_string(),+ started_at: "2025-01-01T00:00:00.000Z".to_string(),+ finished_at: None,+ owner_instance_id: "test-instance".to_string(),+ error_code: None,+ safe_error_summary: None,+ history_complete: false,+ source: TaskEndpointSnapshot {+ connection_id: "source-id".to_string(),+ database_type: "sqlite".to_string(),+ database: "source-db".to_string(),+ schema: "main".to_string(),+ catalog: None,+ },+ target: TaskEndpointSnapshot {+ connection_id: "target-id".to_string(),+ database_type: "sqlite".to_string(),+ database: "target-db".to_string(),+ schema: "main".to_string(),+ catalog: None,+ },+ };+ let details = TransferRunDetails {+ run_id: run.run_id.clone(),+ content: TransferRunContent::DataOnly,+ mode: TransferRunMode::Append,+ batch_size: 500,+ create_table: false,+ drop_target_before_create: false,+ target_table_name_case: TransferRunTargetTableNameCase::Preserve,+ quote_target_column_names: true,+ ownership_policy: TransferRunOwnershipPolicy::Preserve,+ filtered_table_count: 0,+ table_total: 1,+ object_selection_mode: TransferObjectSelectionMode::Explicit,+ selected_object_count: Some(0),+ };+ let item = TaskRunItem {+ run_id: run.run_id.clone(),+ item_index: 0,+ item_kind: TaskItemKind::Table,+ source_object: "orders".to_string(),+ target_object: "orders".to_string(),+ status: TaskItemStatus::Pending,+ source_row_count: None,+ moved_row_count: None,+ target_row_count: None,+ row_count_state: RowCountState::Unknown,+ has_table_filter: false,+ safe_error_summary: None,+ };++ storage.create_task_run(&run, &details, std::slice::from_ref(&item)).await.unwrap();+ assert_eq!(+ storage.create_task_run(&run, &details, std::slice::from_ref(&item)).await,+ Err(TaskHistoryStorageError::RunIdConflict)+ );+ assert_eq!(storage.delete_task_run(&run.run_id).await, Err(TaskHistoryStorageError::RunStillRunning));++ let completed_item = TaskRunItem {+ status: TaskItemStatus::Succeeded,+ source_row_count: Some(0),+ moved_row_count: Some(0),+ row_count_state: RowCountState::Known,+ ..item+ };+ assert!(storage.save_task_run_item(&completed_item).await.unwrap());+ assert!(storage.finish_task_run(&run.run_id, TaskRunStatus::Succeeded, None, None, true).await.unwrap());+ assert!(!storage+ .finish_task_run(&run.run_id, TaskRunStatus::Failed, Some("late"), Some("late"), true)+ .await+ .unwrap());++ let older_run = TaskRun {+ run_id: "history-storage-run-older".to_string(),+ created_at: "2024-12-31T00:00:00.000Z".to_string(),+ started_at: "2024-12-31T00:00:00.000Z".to_string(),+ ..run.clone()+ };+ let older_details = TransferRunDetails { run_id: older_run.run_id.clone(), ..details.clone() };+ storage.create_task_run(&older_run, &older_details, &[]).await.unwrap();+ assert!(storage.finish_task_run(&older_run.run_id, TaskRunStatus::Succeeded, None, None, true).await.unwrap());++ let page = storage.list_task_runs(TaskRunListQuery { limit: Some(1), ..Default::default() }).await.unwrap();+ assert_eq!(page.items.len(), 1);+ assert_eq!(page.items[0].run_id, run.run_id);+ let cursor = page.next_cursor.clone().expect("older run must be available on the next page");+ let next_page = storage+ .list_task_runs(TaskRunListQuery { limit: Some(1), cursor: Some(cursor), ..Default::default() })+ .await+ .unwrap();+ assert_eq!(next_page.items.len(), 1);+ assert_eq!(next_page.items[0].run_id, older_run.run_id);+ assert!(next_page.next_cursor.is_none());+ let item_page = storage+ .list_task_run_items(&run.run_id, TaskRunItemsQuery { limit: Some(1), ..Default::default() })+ .await+ .unwrap();+ assert_eq!(item_page.items[0].source_row_count, Some(0));+ assert_eq!(item_page.items[0].moved_row_count, Some(0));+ assert_eq!(item_page.items[0].target_row_count, None);++ drop(storage);+ let reopened = crate::persistence::test_storage::open_unmigrated(&path).await.unwrap();+ let detail = reopened.get_task_run_detail(&run.run_id).await.unwrap().unwrap();+ assert_eq!(detail.run.status, TaskRunStatus::Succeeded);+ assert!(detail.run.history_complete);+ assert_eq!(detail.transfer.unwrap().selected_object_count, Some(0));+ assert!(reopened.delete_task_run(&run.run_id).await.unwrap());+ assert!(reopened.get_task_run_detail(&run.run_id).await.unwrap().is_none());+ }}diff --git a/crates/dbx-core/src/persistence/task_history.rs b/crates/dbx-core/src/persistence/task_history.rsnew file mode 100644index 0000000000..e76a56abbb--- /dev/null+++ b/crates/dbx-core/src/persistence/task_history.rs@@ -0,0 +1,1018 @@+use std::collections::{HashMap, HashSet};+use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};+use std::sync::{LazyLock, Mutex};++use chrono::{SecondsFormat, Utc};+use serde::{Deserialize, Serialize};++use crate::connection::AppState;+use crate::data::transfer::{+ TransferContent, TransferMode, TransferObjectOutcome, TransferOwnershipPolicy, TransferProgress, TransferRequest,+ TransferStatus, TransferTableNameCase,+};+use crate::persistence::storage::Storage;++const HISTORY_STORAGE_UNAVAILABLE: &str = "Task history storage is unavailable.";+const ITEM_FAILED_SUMMARY: &str = "Transfer item failed.";+const ITEM_CANCELLED_SUMMARY: &str = "Transfer item was cancelled.";+const ITEM_INCOMPLETE_SUMMARY: &str = "Transfer item did not complete.";+const RUN_FAILED_SUMMARY: &str = "Transfer failed before completion.";+const RUN_PARTIAL_SUMMARY: &str = "Transfer completed with failed items.";+const RUN_CANCELLED_SUMMARY: &str = "Transfer was cancelled.";++/// A storage failure is deliberately distinct from a duplicate run identifier.+#[derive(Debug, Clone, Copy, PartialEq, Eq)]+pub enum TaskHistoryStorageError {+ RunIdConflict,+ RunStillRunning,+ StorageUnavailable,+}++impl TaskHistoryStorageError {+ pub const fn code(self) -> &'static str {+ match self {+ Self::RunIdConflict => "TRANSFER_RUN_ID_CONFLICT",+ Self::RunStillRunning => "TASK_RUN_STILL_RUNNING",+ Self::StorageUnavailable => "TASK_HISTORY_STORAGE_UNAVAILABLE",+ }+ }+}++#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "snake_case")]+pub enum TaskType {+ Transfer,+}++impl TaskType {+ pub(crate) const fn as_storage_str(self) -> &'static str {+ match self {+ Self::Transfer => "transfer",+ }+ }++ pub(crate) fn from_storage(value: &str) -> Option<Self> {+ match value {+ "transfer" => Some(Self::Transfer),+ _ => None,+ }+ }+}++#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "snake_case")]+pub enum TaskLifecycleOwner {+ Tauri,+ Web,+}++impl TaskLifecycleOwner {+ pub(crate) const fn as_storage_str(self) -> &'static str {+ match self {+ Self::Tauri => "tauri",+ Self::Web => "web",+ }+ }++ pub(crate) fn from_storage(value: &str) -> Option<Self> {+ match value {+ "tauri" => Some(Self::Tauri),+ "web" => Some(Self::Web),+ _ => None,+ }+ }+}++#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "snake_case")]+pub enum TaskRunStatus {+ Running,+ Succeeded,+ PartialFailed,+ Failed,+ Cancelled,+}++impl TaskRunStatus {+ pub(crate) const fn as_storage_str(self) -> &'static str {+ match self {+ Self::Running => "running",+ Self::Succeeded => "succeeded",+ Self::PartialFailed => "partial_failed",+ Self::Failed => "failed",+ Self::Cancelled => "cancelled",+ }+ }++ pub(crate) fn from_storage(value: &str) -> Option<Self> {+ match value {+ "running" => Some(Self::Running),+ "succeeded" => Some(Self::Succeeded),+ "partial_failed" => Some(Self::PartialFailed),+ "failed" => Some(Self::Failed),+ "cancelled" => Some(Self::Cancelled),+ _ => None,+ }+ }++ pub const fn is_terminal(self) -> bool {+ !matches!(self, Self::Running)+ }+}++#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "snake_case")]+pub enum TransferRunContent {+ StructureAndData,+ StructureOnly,+ DataOnly,+}++impl TransferRunContent {+ fn from_transfer(value: TransferContent) -> Self {+ match value {+ TransferContent::StructureAndData => Self::StructureAndData,+ TransferContent::StructureOnly => Self::StructureOnly,+ TransferContent::DataOnly => Self::DataOnly,+ }+ }++ pub(crate) const fn as_storage_str(self) -> &'static str {+ match self {+ Self::StructureAndData => "structure_and_data",+ Self::StructureOnly => "structure_only",+ Self::DataOnly => "data_only",+ }+ }++ pub(crate) fn from_storage(value: &str) -> Option<Self> {+ match value {+ "structure_and_data" => Some(Self::StructureAndData),+ "structure_only" => Some(Self::StructureOnly),+ "data_only" => Some(Self::DataOnly),+ _ => None,+ }+ }+}++#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "snake_case")]+pub enum TransferRunMode {+ Append,+ Overwrite,+ Upsert,+}++impl TransferRunMode {+ fn from_transfer(value: &TransferMode) -> Self {+ match value {+ TransferMode::Append => Self::Append,+ TransferMode::Overwrite => Self::Overwrite,+ TransferMode::Upsert => Self::Upsert,+ }+ }++ pub(crate) const fn as_storage_str(self) -> &'static str {+ match self {+ Self::Append => "append",+ Self::Overwrite => "overwrite",+ Self::Upsert => "upsert",+ }+ }++ pub(crate) fn from_storage(value: &str) -> Option<Self> {+ match value {+ "append" => Some(Self::Append),+ "overwrite" => Some(Self::Overwrite),+ "upsert" => Some(Self::Upsert),+ _ => None,+ }+ }+}++#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "snake_case")]+pub enum TransferRunTargetTableNameCase {+ Preserve,+ Lower,+ Upper,+}++impl TransferRunTargetTableNameCase {+ fn from_transfer(value: &TransferTableNameCase) -> Self {+ match value {+ TransferTableNameCase::Preserve => Self::Preserve,+ TransferTableNameCase::Lower => Self::Lower,+ TransferTableNameCase::Upper => Self::Upper,+ }+ }++ pub(crate) const fn as_storage_str(self) -> &'static str {+ match self {+ Self::Preserve => "preserve",+ Self::Lower => "lower",+ Self::Upper => "upper",+ }+ }++ pub(crate) fn from_storage(value: &str) -> Option<Self> {+ match value {+ "preserve" => Some(Self::Preserve),+ "lower" => Some(Self::Lower),+ "upper" => Some(Self::Upper),+ _ => None,+ }+ }+}++#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "snake_case")]+pub enum TransferRunOwnershipPolicy {+ Preserve,+ Skip,+ ReassignMissing,+}++impl TransferRunOwnershipPolicy {+ fn from_transfer(value: &TransferOwnershipPolicy) -> Self {+ match value {+ TransferOwnershipPolicy::Preserve => Self::Preserve,+ TransferOwnershipPolicy::Skip => Self::Skip,+ TransferOwnershipPolicy::ReassignMissing => Self::ReassignMissing,+ }+ }++ pub(crate) const fn as_storage_str(self) -> &'static str {+ match self {+ Self::Preserve => "preserve",+ Self::Skip => "skip",+ Self::ReassignMissing => "reassign_missing",+ }+ }++ pub(crate) fn from_storage(value: &str) -> Option<Self> {+ match value {+ "preserve" => Some(Self::Preserve),+ "skip" => Some(Self::Skip),+ "reassign_missing" => Some(Self::ReassignMissing),+ _ => None,+ }+ }+}++#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "snake_case")]+pub enum TransferObjectSelectionMode {+ Unspecified,+ Explicit,+}++impl TransferObjectSelectionMode {+ pub(crate) const fn as_storage_str(self) -> &'static str {+ match self {+ Self::Unspecified => "unspecified",+ Self::Explicit => "explicit",+ }+ }++ pub(crate) fn from_storage(value: &str) -> Option<Self> {+ match value {+ "unspecified" => Some(Self::Unspecified),+ "explicit" => Some(Self::Explicit),+ _ => None,+ }+ }+}++#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "snake_case")]+pub enum TaskItemKind {+ Table,+ View,+ MaterializedView,+ Procedure,+ Function,+ Trigger,+ Sequence,+ Event,+ Object,+}++impl TaskItemKind {+ pub(crate) const fn as_storage_str(self) -> &'static str {+ match self {+ Self::Table => "table",+ Self::View => "view",+ Self::MaterializedView => "materialized_view",+ Self::Procedure => "procedure",+ Self::Function => "function",+ Self::Trigger => "trigger",+ Self::Sequence => "sequence",+ Self::Event => "event",+ Self::Object => "object",+ }+ }++ pub(crate) fn from_storage(value: &str) -> Option<Self> {+ match value {+ "table" => Some(Self::Table),+ "view" => Some(Self::View),+ "materialized_view" => Some(Self::MaterializedView),+ "procedure" => Some(Self::Procedure),+ "function" => Some(Self::Function),+ "trigger" => Some(Self::Trigger),+ "sequence" => Some(Self::Sequence),+ "event" => Some(Self::Event),+ "object" => Some(Self::Object),+ _ => None,+ }+ }++ fn from_transfer(value: &str) -> (Self, String) {+ let Some((kind, name)) = value.split_once(':') else {+ return (Self::Object, value.to_string());+ };+ let kind = match kind {+ "Table" => Self::Table,+ "View" => Self::View,+ "MaterializedView" => Self::MaterializedView,+ "Procedure" => Self::Procedure,+ "Function" => Self::Function,+ "Trigger" => Self::Trigger,+ "Sequence" => Self::Sequence,+ "Event" => Self::Event,+ _ => return (Self::Object, value.to_string()),+ };+ (kind, name.to_string())+ }+}++#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "snake_case")]+pub enum TaskItemStatus {+ Pending,+ Running,+ Succeeded,+ Skipped,+ Failed,+ Cancelled,+ NotStarted,+ Incomplete,+}++impl TaskItemStatus {+ pub(crate) const fn as_storage_str(self) -> &'static str {+ match self {+ Self::Pending => "pending",+ Self::Running => "running",+ Self::Succeeded => "succeeded",+ Self::Skipped => "skipped",+ Self::Failed => "failed",+ Self::Cancelled => "cancelled",+ Self::NotStarted => "not_started",+ Self::Incomplete => "incomplete",+ }+ }++ pub(crate) fn from_storage(value: &str) -> Option<Self> {+ match value {+ "pending" => Some(Self::Pending),+ "running" => Some(Self::Running),+ "succeeded" => Some(Self::Succeeded),+ "skipped" => Some(Self::Skipped),+ "failed" => Some(Self::Failed),+ "cancelled" => Some(Self::Cancelled),+ "not_started" => Some(Self::NotStarted),+ "incomplete" => Some(Self::Incomplete),+ _ => None,+ }+ }+}++#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "snake_case")]+pub enum RowCountState {+ NotApplicable,+ Known,+ Unknown,+ Incomplete,+}++impl RowCountState {+ pub(crate) const fn as_storage_str(self) -> &'static str {+ match self {+ Self::NotApplicable => "not_applicable",+ Self::Known => "known",+ Self::Unknown => "unknown",+ Self::Incomplete => "incomplete",+ }+ }++ pub(crate) fn from_storage(value: &str) -> Option<Self> {+ match value {+ "not_applicable" => Some(Self::NotApplicable),+ "known" => Some(Self::Known),+ "unknown" => Some(Self::Unknown),+ "incomplete" => Some(Self::Incomplete),+ _ => None,+ }+ }+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct TaskEndpointSnapshot {+ pub connection_id: String,+ pub database_type: String,+ pub database: String,+ pub schema: String,+ pub catalog: Option<String>,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct TaskRun {+ pub run_id: String,+ pub task_type: TaskType,+ pub lifecycle_owner: TaskLifecycleOwner,+ pub status: TaskRunStatus,+ pub created_at: String,+ pub started_at: String,+ pub finished_at: Option<String>,+ pub owner_instance_id: String,+ pub error_code: Option<String>,+ pub safe_error_summary: Option<String>,+ /// False until a terminal write succeeds; a crash therefore cannot look complete.+ pub history_complete: bool,+ pub source: TaskEndpointSnapshot,+ pub target: TaskEndpointSnapshot,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct TransferRunDetails {+ pub run_id: String,+ pub content: TransferRunContent,+ pub mode: TransferRunMode,+ pub batch_size: i64,+ pub create_table: bool,+ pub drop_target_before_create: bool,+ pub target_table_name_case: TransferRunTargetTableNameCase,+ pub quote_target_column_names: bool,+ pub ownership_policy: TransferRunOwnershipPolicy,+ pub filtered_table_count: i64,+ pub table_total: i64,+ pub object_selection_mode: TransferObjectSelectionMode,+ pub selected_object_count: Option<i64>,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct TaskRunItem {+ pub run_id: String,+ pub item_index: i64,+ pub item_kind: TaskItemKind,+ pub source_object: String,+ pub target_object: String,+ pub status: TaskItemStatus,+ pub source_row_count: Option<i64>,+ /// Rows moved by this Transfer item, never the target's final row count.+ pub moved_row_count: Option<i64>,+ pub target_row_count: Option<i64>,+ /// Null target_row_count means the target row count was not validated.+ pub row_count_state: RowCountState,+ pub has_table_filter: bool,+ pub safe_error_summary: Option<String>,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct TaskRunDetail {+ pub run: TaskRun,+ pub transfer: Option<TransferRunDetails>,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct TaskRunCursor {+ pub created_at: String,+ pub run_id: String,+}++#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct TaskRunListQuery {+ pub limit: Option<usize>,+ pub cursor: Option<TaskRunCursor>,+ pub task_type: Option<TaskType>,+ pub status: Option<TaskRunStatus>,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct TaskRunPage {+ pub items: Vec<TaskRun>,+ pub next_cursor: Option<TaskRunCursor>,+}++#[derive(Debug, Clone, Default, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct TaskRunItemsQuery {+ pub limit: Option<usize>,+ pub after_item_index: Option<i64>,+}++#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq)]+#[serde(rename_all = "camelCase")]+pub struct TaskRunItemsPage {+ pub items: Vec<TaskRunItem>,+ pub next_after_item_index: Option<i64>,+}++#[derive(Debug, Clone)]+struct TableSnapshot {+ source_object: String,+ target_object: String,+ has_table_filter: bool,+}++#[derive(Debug, Clone, Copy, Default)]+struct ObservedRows {+ source_row_count: Option<u64>,+ moved_row_count: Option<u64>,+}++/// Per-transfer observer. It persists only request facts and result-boundary updates;+/// raw TransferRequest, table filters, SQL, and driver error strings are never retained.+#[derive(Clone)]+pub struct TransferTaskJournal {+ storage: Storage,+ run_id: String,+ content: TransferRunContent,+ tables: std::sync::Arc<Vec<TableSnapshot>>,+ history_complete: std::sync::Arc<AtomicBool>,+ successful_items: std::sync::Arc<AtomicUsize>,+ observed_rows: std::sync::Arc<Mutex<HashMap<usize, ObservedRows>>>,+}++static UNPERSISTED_RUN_ID_CLAIMS: LazyLock<Mutex<HashSet<String>>> = LazyLock::new(|| Mutex::new(HashSet::new()));+static OWNER_INSTANCE_ID: LazyLock<String> =+ LazyLock::new(|| format!("{}-{}", std::process::id(), uuid::Uuid::new_v4()));++impl TransferTaskJournal {+ /// Create the durable acceptance record. Storage errors degrade to an unavailable+ /// observer; ID collisions remain an explicit rejection before any Transfer starts.+ pub async fn accept(+ storage: &Storage,+ app: &AppState,+ request: &TransferRequest,+ lifecycle_owner: TaskLifecycleOwner,+ ) -> Result<Option<Self>, TaskHistoryStorageError> {+ {+ let mut claims = UNPERSISTED_RUN_ID_CLAIMS.lock().unwrap_or_else(std::sync::PoisonError::into_inner);+ if !claims.insert(request.transfer_id.clone()) {+ return Err(TaskHistoryStorageError::RunIdConflict);+ }+ }++ let (source_type, target_type) = {+ let configs = app.configs.read().await;+ (+ configs.get(&request.source_connection_id).map(|config| config.db_type.as_str().to_string()),+ configs.get(&request.target_connection_id).map(|config| config.db_type.as_str().to_string()),+ )+ };+ let now = Utc::now().to_rfc3339_opts(SecondsFormat::Millis, true);+ let source = endpoint_snapshot(+ &request.source_connection_id,+ source_type.unwrap_or_else(|| "unknown".to_string()),+ &request.source_database,+ &request.source_schema,+ request.source_catalog.clone(),+ );+ let target = endpoint_snapshot(+ &request.target_connection_id,+ target_type.unwrap_or_else(|| "unknown".to_string()),+ &request.target_database,+ &request.target_schema,+ request.target_catalog.clone(),+ );+ let content = TransferRunContent::from_transfer(request.content);+ let tables = std::sync::Arc::new(+ request+ .tables+ .iter()+ .map(|table| TableSnapshot {+ source_object: table.clone(),+ target_object: request.target_table_name(table),+ has_table_filter: request.table_filters.get(table).is_some_and(|filter| !filter.trim().is_empty()),+ })+ .collect::<Vec<_>>(),+ );+ let run = TaskRun {+ run_id: request.transfer_id.clone(),+ task_type: TaskType::Transfer,+ lifecycle_owner,+ status: TaskRunStatus::Running,+ created_at: now.clone(),+ started_at: now,+ finished_at: None,+ owner_instance_id: OWNER_INSTANCE_ID.clone(),+ error_code: None,+ safe_error_summary: None,+ history_complete: false,+ source,+ target,+ };+ let details = transfer_details(request);+ let items = tables+ .iter()+ .enumerate()+ .map(|(index, table)| TaskRunItem {+ run_id: request.transfer_id.clone(),+ item_index: index as i64,+ item_kind: TaskItemKind::Table,+ source_object: table.source_object.clone(),+ target_object: table.target_object.clone(),+ status: TaskItemStatus::Pending,+ source_row_count: None,+ moved_row_count: None,+ target_row_count: None,+ row_count_state: if content == TransferRunContent::StructureOnly {+ RowCountState::NotApplicable+ } else {+ RowCountState::Unknown+ },+ has_table_filter: table.has_table_filter,+ safe_error_summary: None,+ })+ .collect::<Vec<_>>();++ match storage.create_task_run(&run, &details, &items).await {+ Ok(()) => {+ let mut claims = UNPERSISTED_RUN_ID_CLAIMS.lock().unwrap_or_else(std::sync::PoisonError::into_inner);+ claims.remove(&request.transfer_id);+ Ok(Some(Self {+ storage: storage.clone(),+ run_id: request.transfer_id.clone(),+ content,+ tables,+ history_complete: std::sync::Arc::new(AtomicBool::new(true)),+ successful_items: std::sync::Arc::new(AtomicUsize::new(0)),+ observed_rows: std::sync::Arc::new(Mutex::new(HashMap::new())),+ }))+ }+ Err(TaskHistoryStorageError::RunIdConflict) => {+ let mut claims = UNPERSISTED_RUN_ID_CLAIMS.lock().unwrap_or_else(std::sync::PoisonError::into_inner);+ claims.remove(&request.transfer_id);+ Err(TaskHistoryStorageError::RunIdConflict)+ }+ Err(TaskHistoryStorageError::RunStillRunning) => unreachable!("run creation cannot return this error"),+ Err(TaskHistoryStorageError::StorageUnavailable) => {+ log::warn!("[task-history] {HISTORY_STORAGE_UNAVAILABLE} Transfer will continue without a durable history record.");+ // Keep this process-local claim until exit: a second submission with the same+ // ID must not start another Transfer after the initial journal write failed.+ Ok(None)+ }+ }+ }++ pub fn run_id(&self) -> &str {+ &self.run_id+ }++ /// Return the stable request-order index for a table after the executor sorts its work.+ pub fn item_index_for_table(&self, source_object: &str) -> Option<usize> {+ self.tables.iter().position(|table| table.source_object == source_object)+ }++ pub async fn start_table(&self, item_index: usize) {+ let Some(table) = self.tables.get(item_index) else {+ self.mark_write_failed("table start");+ return;+ };+ let item = TaskRunItem {+ run_id: self.run_id.clone(),+ item_index: item_index as i64,+ item_kind: TaskItemKind::Table,+ source_object: table.source_object.clone(),+ target_object: table.target_object.clone(),+ status: TaskItemStatus::Running,+ source_row_count: None,+ moved_row_count: None,+ target_row_count: None,+ row_count_state: if self.content == TransferRunContent::StructureOnly {+ RowCountState::NotApplicable+ } else {+ RowCountState::Unknown+ },+ has_table_filter: table.has_table_filter,+ safe_error_summary: None,+ };+ self.persist_item(item).await;+ }++ /// Capture row progress in memory only. It is flushed at the table's result boundary.+ pub fn observe_table_progress(&self, item_index: usize, moved_row_count: u64) {+ if let Ok(mut rows) = self.observed_rows.lock() {+ rows.entry(item_index).or_default().moved_row_count = Some(moved_row_count);+ }+ }++ /// Record the source COUNT result from the Transfer executor without changing its public+ /// progress event contract. `None` means the source count was not obtained.+ pub fn observe_source_count(&self, item_index: usize, source_row_count: Option<u64>) {+ if let Ok(mut rows) = self.observed_rows.lock() {+ rows.entry(item_index).or_default().source_row_count = source_row_count;+ }+ }++ pub async fn finish_table(+ &self,+ item_index: usize,+ status: TaskItemStatus,+ source_row_count: Option<u64>,+ moved_row_count: Option<u64>,+ ) {+ let Some(table) = self.tables.get(item_index) else {+ self.mark_write_failed("table result");+ return;+ };+ let observed =+ self.observed_rows.lock().ok().and_then(|rows| rows.get(&item_index).copied()).unwrap_or_default();+ let source_count = source_row_count.or(observed.source_row_count);+ let moved_count = moved_row_count.or(observed.moved_row_count);+ let (source_row_count, moved_row_count, row_count_state) = if self.content == TransferRunContent::StructureOnly+ {+ (None, None, RowCountState::NotApplicable)+ } else if matches!(status, TaskItemStatus::Succeeded) {+ let source = source_count.and_then(to_sqlite_count);+ let moved = moved_count.and_then(to_sqlite_count);+ let state = if source.is_some() && moved.is_some() { RowCountState::Known } else { RowCountState::Unknown };+ (source, moved, state)+ } else {+ (source_count.and_then(to_sqlite_count), moved_count.and_then(to_sqlite_count), RowCountState::Incomplete)+ };+ self.persist_item(TaskRunItem {+ run_id: self.run_id.clone(),+ item_index: item_index as i64,+ item_kind: TaskItemKind::Table,+ source_object: table.source_object.clone(),+ target_object: table.target_object.clone(),+ status,+ source_row_count,+ moved_row_count,+ target_row_count: None,+ row_count_state,+ has_table_filter: table.has_table_filter,+ safe_error_summary: safe_item_summary(status),+ })+ .await;+ }++ pub async fn record_object_outcome(&self, outcome: &TransferObjectOutcome) {+ let mut next_index = self.tables.len();+ for (items, status) in [+ (&outcome.transferred, TaskItemStatus::Succeeded),+ (&outcome.skipped, TaskItemStatus::Skipped),+ (&outcome.failed, TaskItemStatus::Failed),+ ] {+ for raw in items {+ let (item_kind, source_object) = TaskItemKind::from_transfer(raw);+ self.persist_item(TaskRunItem {+ run_id: self.run_id.clone(),+ item_index: next_index as i64,+ item_kind,+ source_object: source_object.clone(),+ target_object: source_object,+ status,+ source_row_count: None,+ moved_row_count: None,+ target_row_count: None,+ row_count_state: RowCountState::NotApplicable,+ has_table_filter: false,+ safe_error_summary: safe_item_summary(status),+ })+ .await;+ next_index += 1;+ }+ }+ }++ pub async fn record_schema_objects_error(&self, cancelled: bool) {+ let status = if cancelled { TaskItemStatus::Cancelled } else { TaskItemStatus::Failed };+ self.persist_item(TaskRunItem {+ run_id: self.run_id.clone(),+ item_index: self.tables.len() as i64,+ item_kind: TaskItemKind::Object,+ source_object: "schema objects".to_string(),+ target_object: "schema objects".to_string(),+ status,+ source_row_count: None,+ moved_row_count: None,+ target_row_count: None,+ row_count_state: RowCountState::NotApplicable,+ has_table_filter: false,+ safe_error_summary: safe_item_summary(status),+ })+ .await;+ }++ pub async fn finish(&self, progress: &TransferProgress) {+ if !progress.terminal {+ return;+ }+ let (status, error_code, safe_summary) = match &progress.status {+ TransferStatus::Done => (TaskRunStatus::Succeeded, None, None),+ TransferStatus::Cancelled => (+ TaskRunStatus::Cancelled,+ Some("TRANSFER_CANCELLED".to_string()),+ Some(RUN_CANCELLED_SUMMARY.to_string()),+ ),+ TransferStatus::Error => {+ if self.successful_items.load(Ordering::Relaxed) > 0 {+ (+ TaskRunStatus::PartialFailed,+ Some("TRANSFER_PARTIAL_FAILURE".to_string()),+ Some(RUN_PARTIAL_SUMMARY.to_string()),+ )+ } else {+ (TaskRunStatus::Failed, Some("TRANSFER_FAILED".to_string()), Some(RUN_FAILED_SUMMARY.to_string()))+ }+ }+ TransferStatus::Running | TransferStatus::TableDone => return,+ };+ let history_complete = self.history_complete.load(Ordering::Relaxed);+ if self+ .storage+ .finish_task_run(&self.run_id, status, error_code.as_deref(), safe_summary.as_deref(), history_complete)+ .await+ .is_err()+ {+ log::warn!("[task-history] terminal history write failed; transfer result is unchanged and the run remains unconfirmed.");+ }+ }++ async fn persist_item(&self, item: TaskRunItem) {+ if item.status == TaskItemStatus::Succeeded {+ self.successful_items.fetch_add(1, Ordering::Relaxed);+ }+ if self.storage.save_task_run_item(&item).await.is_err() {+ self.mark_write_failed("item result");+ }+ }++ fn mark_write_failed(&self, stage: &'static str) {+ self.history_complete.store(false, Ordering::Relaxed);+ log::warn!("[task-history] {stage} could not be persisted; Transfer continues and history is incomplete.");+ }+}++fn endpoint_snapshot(+ connection_id: &str,+ database_type: String,+ database: &str,+ schema: &str,+ catalog: Option<String>,+) -> TaskEndpointSnapshot {+ TaskEndpointSnapshot {+ connection_id: connection_id.to_string(),+ database_type,+ database: database.to_string(),+ schema: schema.to_string(),+ catalog,+ }+}++fn transfer_details(request: &TransferRequest) -> TransferRunDetails {+ let object_selection_mode = if request.objects.is_some() {+ TransferObjectSelectionMode::Explicit+ } else {+ TransferObjectSelectionMode::Unspecified+ };+ let selected_object_count = request+ .objects+ .as_ref()+ .map(|objects| objects.iter().map(|selection| selection.names.len()).sum::<usize>() as i64);+ TransferRunDetails {+ run_id: request.transfer_id.clone(),+ content: TransferRunContent::from_transfer(request.content),+ mode: TransferRunMode::from_transfer(&request.mode),+ batch_size: i64::try_from(request.batch_size).unwrap_or(i64::MAX),+ create_table: request.create_table,+ drop_target_before_create: request.drop_target_before_create,+ target_table_name_case: TransferRunTargetTableNameCase::from_transfer(&request.target_table_name_case),+ quote_target_column_names: request.quote_target_column_names,+ ownership_policy: TransferRunOwnershipPolicy::from_transfer(&request.ownership_policy),+ filtered_table_count: request+ .tables+ .iter()+ .filter(|table| request.table_filters.get(*table).is_some_and(|filter| !filter.trim().is_empty()))+ .count() as i64,+ table_total: request.tables.len() as i64,+ object_selection_mode,+ selected_object_count,+ }+}++fn safe_item_summary(status: TaskItemStatus) -> Option<String> {+ match status {+ TaskItemStatus::Failed => Some(ITEM_FAILED_SUMMARY.to_string()),+ TaskItemStatus::Cancelled => Some(ITEM_CANCELLED_SUMMARY.to_string()),+ TaskItemStatus::Incomplete => Some(ITEM_INCOMPLETE_SUMMARY.to_string()),+ _ => None,+ }+}++fn to_sqlite_count(value: u64) -> Option<i64> {+ i64::try_from(value).ok()+}++#[cfg(test)]+mod tests {+ use super::*;+ use crate::data::transfer::{+ TransferMode, TransferObjectSelection, TransferOwnershipPolicy, TransferTableNameCase,+ };++ #[tokio::test]+ async fn journal_drops_raw_filters_and_driver_errors_from_persistent_history() {+ let dir = tempfile::tempdir().unwrap();+ let db_path = dir.path().join("dbx.db");+ let storage = crate::persistence::test_storage::open_unmigrated(&db_path).await.unwrap();+ let app = AppState::new_with_plugin_dir(storage.clone(), dir.path().join("plugins"));+ let filter_secret = "task_history_filter_secret_marker";+ let driver_secret = "task_history_driver_error_secret_marker";+ let request = TransferRequest {+ transfer_id: format!("task-history-test-{}", uuid::Uuid::new_v4()),+ source_connection_id: "source-id".to_string(),+ source_database: "source-db".to_string(),+ source_schema: "main".to_string(),+ source_catalog: None,+ target_connection_id: "target-id".to_string(),+ target_database: "target-db".to_string(),+ target_schema: "main".to_string(),+ target_catalog: None,+ tables: vec!["orders".to_string()],+ create_table: false,+ content: TransferContent::DataOnly,+ objects: Some(vec![TransferObjectSelection::default()]),+ mode: TransferMode::Append,+ target_table_name_case: TransferTableNameCase::Preserve,+ quote_target_column_names: true,+ ownership_policy: TransferOwnershipPolicy::Preserve,+ batch_size: 500,+ table_filters: HashMap::from([+ ("orders".to_string(), format!("WHERE note = '{filter_secret}'")),+ ("unselected_table".to_string(), format!("WHERE note = '{filter_secret}'")),+ ]),+ drop_target_before_create: false,+ drop_target_confirmed: false,+ };+ let journal =+ TransferTaskJournal::accept(&storage, &app, &request, TaskLifecycleOwner::Web).await.unwrap().unwrap();+ assert!(matches!(+ TransferTaskJournal::accept(&storage, &app, &request, TaskLifecycleOwner::Web).await,+ Err(TaskHistoryStorageError::RunIdConflict)+ ));++ journal.start_table(0).await;+ journal.observe_source_count(0, None);+ journal.observe_table_progress(0, 2);+ journal.finish_table(0, TaskItemStatus::Failed, None, None).await;+ journal+ .finish(&TransferProgress {+ transfer_id: request.transfer_id.clone(),+ table: "orders".to_string(),+ table_index: 0,+ total_tables: 1,+ rows_transferred: 2,+ total_rows: None,+ status: TransferStatus::Error,+ error: Some(driver_secret.to_string()),+ terminal: true,+ })+ .await;++ let detail = storage.get_task_run_detail(&request.transfer_id).await.unwrap().unwrap();+ assert_eq!(detail.run.status, TaskRunStatus::Failed);+ assert!(detail.run.history_complete);+ assert_eq!(detail.run.error_code.as_deref(), Some("TRANSFER_FAILED"));+ assert_eq!(detail.transfer.as_ref().unwrap().filtered_table_count, 1);+ let items = storage.list_task_run_items(&request.transfer_id, TaskRunItemsQuery::default()).await.unwrap();+ assert_eq!(items.items[0].source_row_count, None);+ assert_eq!(items.items[0].moved_row_count, Some(2));+ assert_eq!(items.items[0].target_row_count, None);+ assert_eq!(items.items[0].row_count_state, RowCountState::Incomplete);+ assert_eq!(items.items[0].safe_error_summary.as_deref(), Some(ITEM_FAILED_SUMMARY));++ let serialized = serde_json::to_string(&(detail, items)).unwrap();+ assert!(!serialized.contains(filter_secret));+ assert!(!serialized.contains(driver_secret));+ for path in [db_path.clone(), db_path.with_extension("db-wal"), db_path.with_extension("db-shm")] {+ let bytes = std::fs::read(path).unwrap_or_default();+ assert!(!bytes.windows(filter_secret.len()).any(|window| window == filter_secret.as_bytes()));+ assert!(!bytes.windows(driver_secret.len()).any(|window| window == driver_secret.as_bytes()));+ }+ }+}diff --git a/crates/dbx-web/src/error.rs b/crates/dbx-web/src/error.rsindex 2e2f56bf68..2f93aa2634 100644--- a/crates/dbx-web/src/error.rs+++ b/crates/dbx-web/src/error.rs@@ -26,6 +26,10 @@ impl AppError {Self::with_status(msg.into(), StatusCode::BAD_REQUEST)}+ pub fn conflict(msg: impl Into<String>) -> Self {+ Self::with_status(msg.into(), StatusCode::CONFLICT)+ }+pub fn forbidden(msg: impl Into<String>) -> Self {Self::with_status(msg.into(), StatusCode::FORBIDDEN)}diff --git a/crates/dbx-web/src/main.rs b/crates/dbx-web/src/main.rsindex 1f34486779..8e3d15c410 100644--- a/crates/dbx-web/src/main.rs+++ b/crates/dbx-web/src/main.rs@@ -1322,6 +1322,9 @@ async fn serve() -> Result<(), String> {// Transfer.route("/transfer/start", post(routes::transfer::start_transfer)).route("/transfer/ownership-preview", post(routes::transfer::preview_transfer_ownership))+ .route("/task-runs", get(routes::task_history::list_task_runs))+ .route("/task-runs/{run_id}", get(routes::task_history::get_task_run))+ .route("/task-runs/{run_id}/items", get(routes::task_history::list_task_run_items)).route("/transfer/progress/{transferId}", get(routes::transfer::transfer_progress)).route("/transfer/cancel", post(routes::transfer::cancel_transfer)).route("/transfer/sort-tables-by-fk", post(routes::transfer::sort_tables_by_fk_dependency))diff --git a/crates/dbx-web/src/routes/mod.rs b/crates/dbx-web/src/routes/mod.rsindex cad1245de3..9cefd08656 100644--- a/crates/dbx-web/src/routes/mod.rs+++ b/crates/dbx-web/src/routes/mod.rs@@ -40,6 +40,7 @@ pub mod ssh_prompt;pub mod tab_runtime_cache;pub mod table_export;pub mod table_import;+pub mod task_history;pub mod text_export;pub mod transfer;pub mod tunnel_profiles;diff --git a/crates/dbx-web/src/routes/task_history.rs b/crates/dbx-web/src/routes/task_history.rsnew file mode 100644index 0000000000..e43711399f--- /dev/null+++ b/crates/dbx-web/src/routes/task_history.rs@@ -0,0 +1,75 @@+use std::sync::Arc;++use axum::extract::{Path, Query, State};+use axum::Json;+use dbx_core::persistence::task_history::{+ TaskRunCursor, TaskRunDetail, TaskRunItemsPage, TaskRunItemsQuery, TaskRunListQuery, TaskRunPage, TaskRunStatus,+ TaskType,+};+use serde::Deserialize;++use crate::error::AppError;+use crate::state::WebState;++#[derive(Debug, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct TaskRunListParams {+ pub limit: Option<usize>,+ pub cursor_created_at: Option<String>,+ pub cursor_run_id: Option<String>,+ pub task_type: Option<TaskType>,+ pub status: Option<TaskRunStatus>,+}++#[derive(Debug, Deserialize)]+#[serde(rename_all = "camelCase")]+pub struct TaskRunItemsParams {+ pub limit: Option<usize>,+ pub after_item_index: Option<i64>,+}++pub async fn list_task_runs(+ State(state): State<Arc<WebState>>,+ Query(params): Query<TaskRunListParams>,+) -> Result<Json<TaskRunPage>, AppError> {+ let cursor = match (params.cursor_created_at, params.cursor_run_id) {+ (Some(created_at), Some(run_id)) => Some(TaskRunCursor { created_at, run_id }),+ (None, None) => None,+ _ => return Err(AppError::bad_request("Both cursorCreatedAt and cursorRunId are required.")),+ };+ let query = TaskRunListQuery { limit: params.limit, cursor, task_type: params.task_type, status: params.status };+ state.app.storage.list_task_runs(query).await.map(Json).map_err(|error| AppError::internal(error.code()))+}++pub async fn get_task_run(+ State(state): State<Arc<WebState>>,+ Path(run_id): Path<String>,+) -> Result<Json<TaskRunDetail>, AppError> {+ state+ .app+ .storage+ .get_task_run_detail(&run_id)+ .await+ .map_err(|error| AppError::internal(error.code()))?+ .map(Json)+ .ok_or_else(|| AppError::not_found("TASK_RUN_NOT_FOUND"))+}++pub async fn list_task_run_items(+ State(state): State<Arc<WebState>>,+ Path(run_id): Path<String>,+ Query(params): Query<TaskRunItemsParams>,+) -> Result<Json<TaskRunItemsPage>, AppError> {+ if state.app.storage.get_task_run_detail(&run_id).await.map_err(|error| AppError::internal(error.code()))?.is_none()+ {+ return Err(AppError::not_found("TASK_RUN_NOT_FOUND"));+ }+ let query = TaskRunItemsQuery { limit: params.limit, after_item_index: params.after_item_index };+ state+ .app+ .storage+ .list_task_run_items(&run_id, query)+ .await+ .map(Json)+ .map_err(|error| AppError::internal(error.code()))+}diff --git a/crates/dbx-web/src/routes/transfer.rs b/crates/dbx-web/src/routes/transfer.rsindex f3e77c15c5..3cb21f1d0a 100644--- a/crates/dbx-web/src/routes/transfer.rs+++ b/crates/dbx-web/src/routes/transfer.rs@@ -3,6 +3,9 @@ use std::sync::Arc;use axum::extract::{Path, State};use axum::response::sse::{Event, Sse};use axum::Json;+use dbx_core::persistence::task_history::{+ TaskHistoryStorageError, TaskItemStatus, TaskLifecycleOwner, TransferTaskJournal,+};use dbx_core::transfer::{self, TransferRequest, TransferStatus};use futures::stream::Stream;use serde::Deserialize;@@ -15,6 +18,9 @@ use crate::state::WebState;const COMPLETED_TRANSFER_CHANNEL_TTL: Duration = Duration::from_secs(60);fn send_transfer_progress(channel: &TransferProgressChannel, progress: &transfer::TransferProgress) {+ if progress.terminal {+ channel.remember_terminal_progress(progress.clone());+ }if let Ok(json) = serde_json::to_string(progress) {let kind = if progress.terminal {TransferReplayEventKind::Terminal@@ -42,6 +48,7 @@ fn terminal_transfer_error(req: &TransferRequest, error: impl ToString) -> trans}async fn finish_transfer_channel(state: &Arc<WebState>, transfer_id: &str, channel: &Arc<TransferProgressChannel>) {+ channel.finish_task_history().await;transfer::clear_cancelled(transfer_id).await;let state = state.clone();let transfer_id = transfer_id.to_string();@@ -106,10 +113,22 @@ pub async fn start_transfer(}let transfer_id = req.transfer_id.clone();+ let history = if state.demo_mode {+ None+ } else {+ match TransferTaskJournal::accept(&state.app.storage, &state.app, &req, TaskLifecycleOwner::Web).await {+ Ok(history) => history,+ Err(TaskHistoryStorageError::RunIdConflict) => {+ return Err(AppError::conflict("TRANSFER_RUN_ID_CONFLICT"));+ }+ Err(error) => return Err(AppError::internal(error.code())),+ }+ };// Keep bounded replay state so a web EventSource opened after this POST// still receives early table failures and the terminal result.let progress_channel = Arc::new(TransferProgressChannel::new());+ progress_channel.set_task_history_journal(history.clone());state.transfer_progress_channels.write().await.insert(transfer_id.clone(), progress_channel.clone());let app = state.app.clone();@@ -370,10 +389,19 @@ pub async fn start_transfer(return;}+ let history_item_index =+ history.as_ref().and_then(|journal| journal.item_index_for_table(table)).unwrap_or(i);+ if let Some(journal) = history.as_ref() {+ journal.start_table(history_item_index).await;+ }let progress_channel_clone = progress_channel.clone();let mut last_rows_transferred = 0_u64;let mut last_total_rows = None;- let result = transfer::transfer_table(+ let mut source_row_count = None;+ let mut moved_row_count = None;+ let history_for_progress = history.as_ref();+ let history_for_count = history.as_ref();+ let result = transfer::transfer_table_with_result(&app,&req,table,@@ -388,20 +416,40 @@ pub async fn start_transfer(|progress| {last_rows_transferred = progress.rows_transferred;last_total_rows = progress.total_rows;+ moved_row_count = Some(progress.rows_transferred);+ if let Some(journal) = history_for_progress {+ journal.observe_table_progress(history_item_index, progress.rows_transferred);+ }send_transfer_progress(&progress_channel_clone, &progress);},+ |source_count| {+ source_row_count = source_count;+ if let Some(journal) = history_for_count {+ journal.observe_source_count(history_item_index, source_count);+ }+ },).await;match result {- Ok(rows) => {+ Ok(result) => {+ if let Some(journal) = history.as_ref() {+ journal+ .finish_table(+ history_item_index,+ TaskItemStatus::Succeeded,+ result.source_row_count,+ Some(result.moved_rows),+ )+ .await;+ }let progress = transfer::TransferProgress {transfer_id: req.transfer_id.clone(),table: table.clone(),table_index: i,total_tables: tables.len(),- rows_transferred: rows,- total_rows: last_total_rows.or(Some(rows)),+ rows_transferred: result.moved_rows,+ total_rows: last_total_rows.or(Some(result.moved_rows)),status: TransferStatus::TableDone,error: None,terminal: false,@@ -410,6 +458,16 @@ pub async fn start_transfer(}Err(e) => {if e == "Cancelled" {+ if let Some(journal) = history.as_ref() {+ journal+ .finish_table(+ history_item_index,+ TaskItemStatus::Cancelled,+ source_row_count,+ moved_row_count,+ )+ .await;+ }let progress = transfer::TransferProgress {transfer_id: req.transfer_id.clone(),table: table.clone(),@@ -425,6 +483,11 @@ pub async fn start_transfer(finish_transfer_channel(&state_clone, &req.transfer_id, &progress_channel).await;return;}+ if let Some(journal) = history.as_ref() {+ journal+ .finish_table(history_item_index, TaskItemStatus::Failed, source_row_count, moved_row_count)+ .await;+ }failed_tables.push(table.clone());let progress = transfer::TransferProgress {transfer_id: req.transfer_id.clone(),@@ -476,9 +539,15 @@ pub async fn start_transfer(.await{Ok(outcome) => {+ if let Some(journal) = history.as_ref() {+ journal.record_object_outcome(&outcome).await;+ }object_outcome = outcome;}Err(e) if e == "Cancelled" => {+ if let Some(journal) = history.as_ref() {+ journal.record_schema_objects_error(true).await;+ }let progress = transfer::TransferProgress {transfer_id: req.transfer_id.clone(),table: "schema objects".to_string(),@@ -495,6 +564,9 @@ pub async fn start_transfer(return;}Err(e) => {+ if let Some(journal) = history.as_ref() {+ journal.record_schema_objects_error(false).await;+ }failed_tables.push("schema objects".to_string());let progress = transfer::TransferProgress {transfer_id: req.transfer_id.clone(),@@ -673,6 +745,7 @@ mod tests {default_connect_timeout_secs, default_idle_timeout_secs, default_keepalive_interval_secs,default_query_timeout_secs, ConnectionConfig, DatabaseType,};+ use dbx_core::persistence::task_history::{TaskRunItemsQuery, TaskRunStatus, TransferObjectSelectionMode};use dbx_core::transfer::{TransferContent, TransferMode, TransferOwnershipPolicy, TransferRequest, TransferTableNameCase,};@@ -801,6 +874,14 @@ mod tests {let response = start_transfer(State(state.clone()), Json(StartTransferRequest { request: req })).await.unwrap();let _ = response.into_response();+ let duplicate = start_transfer(+ State(state.clone()),+ Json(StartTransferRequest { request: transfer_request("src", "dst", &dir) }),+ )+ .await+ .unwrap_err();+ assert_eq!(duplicate.status, axum::http::StatusCode::CONFLICT);+// Both HTTP and Tauri call the same Core schema-object stage// unconditionally. DataOnly must resolve there to a no-op without an// object progress event or database-family fallback.@@ -837,6 +918,54 @@ mod tests {terminal_error.is_none(),"DataOnly must complete without a schema-object error, got: {terminal_error:?}");+ let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);+ let task_run = loop {+ let run = state.app.storage.get_task_run_detail(&transfer_id).await.unwrap();+ if run.as_ref().is_some_and(|detail| detail.run.status.is_terminal()) {+ break run.unwrap();+ }+ if std::time::Instant::now() > deadline {+ panic!("task history did not reach a terminal state");+ }+ tokio::time::sleep(std::time::Duration::from_millis(10)).await;+ };+ assert_eq!(task_run.run.lifecycle_owner, TaskLifecycleOwner::Web);+ assert_eq!(task_run.run.status, TaskRunStatus::Succeeded);+ assert!(task_run.run.history_complete);+ let transfer_details = task_run.transfer.expect("accepted transfer details persisted");+ assert_eq!(transfer_details.object_selection_mode, TransferObjectSelectionMode::Explicit);+ assert_eq!(transfer_details.selected_object_count, Some(0));+ let items = state.app.storage.list_task_run_items(&transfer_id, TaskRunItemsQuery::default()).await.unwrap();+ assert!(items.items.is_empty());+ let _ = std::fs::remove_dir_all(&dir);+ }++ #[tokio::test]+ async fn demo_mode_transfer_does_not_write_task_history() {+ let (mut state, dir) = test_web_state().await;+ Arc::get_mut(&mut state).unwrap().demo_mode = true;+ let req = transfer_request("src", "dst", &dir);+ let transfer_id = req.transfer_id.clone();+ let _ = start_transfer(State(state.clone()), Json(StartTransferRequest { request: req })).await.unwrap();+ let channel = {+ let channels = state.transfer_progress_channels.read().await;+ channels.get(&transfer_id).cloned().expect("transfer channel registered")+ };+ let deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);+ loop {+ if channel+ .latest()+ .and_then(|data| serde_json::from_str::<serde_json::Value>(&data).ok())+ .is_some_and(|progress| progress["terminal"].as_bool() == Some(true))+ {+ break;+ }+ if std::time::Instant::now() > deadline {+ panic!("demo transfer did not reach a terminal event");+ }+ tokio::time::sleep(std::time::Duration::from_millis(10)).await;+ }+ assert!(state.app.storage.get_task_run_detail(&transfer_id).await.unwrap().is_none());let _ = std::fs::remove_dir_all(&dir);}}diff --git a/crates/dbx-web/src/sse.rs b/crates/dbx-web/src/sse.rsindex 43373e7a94..8158a02855 100644--- a/crates/dbx-web/src/sse.rs+++ b/crates/dbx-web/src/sse.rs@@ -1,4 +1,6 @@use axum::response::sse::{Event, KeepAlive, Sse};+use dbx_core::persistence::task_history::TransferTaskJournal;+use dbx_core::transfer::TransferProgress;use futures::stream::Stream;use serde_json::Value;use std::collections::VecDeque;@@ -22,6 +24,8 @@ struct TransferReplayHistory {failure_bytes: usize,latest: Option<String>,omitted_failures: usize,+ task_history_journal: Option<TransferTaskJournal>,+ terminal_progress: Option<TransferProgress>,}pub struct TransferProgressChannel {@@ -35,6 +39,24 @@ impl TransferProgressChannel {Self { tx, history: Mutex::new(TransferReplayHistory::default()) }}+ pub fn set_task_history_journal(&self, journal: Option<TransferTaskJournal>) {+ self.history.lock().unwrap_or_else(|poisoned| poisoned.into_inner()).task_history_journal = journal;+ }++ pub fn remember_terminal_progress(&self, progress: TransferProgress) {+ self.history.lock().unwrap_or_else(|poisoned| poisoned.into_inner()).terminal_progress = Some(progress);+ }++ pub async fn finish_task_history(&self) {+ let (journal, progress) = {+ let history = self.history.lock().unwrap_or_else(|poisoned| poisoned.into_inner());+ (history.task_history_journal.clone(), history.terminal_progress.clone())+ };+ if let (Some(journal), Some(progress)) = (journal, progress) {+ journal.finish(&progress).await;+ }+ }+pub fn send(&self, data: String, kind: TransferReplayEventKind) {let mut history = self.history.lock().unwrap_or_else(|poisoned| poisoned.into_inner());match kind {diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rsindex 5f97efa5c6..018764dc3a 100644--- a/src-tauri/src/commands/mod.rs+++ b/src-tauri/src/commands/mod.rs@@ -64,6 +64,7 @@ pub mod system_fonts;pub mod tab_runtime_cache;pub mod table_export;pub mod table_import;+pub mod task_history;pub mod text_export;pub mod transfer;pub mod tunnel_profiles;diff --git a/src-tauri/src/commands/task_history.rs b/src-tauri/src/commands/task_history.rsnew file mode 100644index 0000000000..08c77052eb--- /dev/null+++ b/src-tauri/src/commands/task_history.rs@@ -0,0 +1,27 @@+use std::sync::Arc;++use tauri::State;++use super::connection::AppState;+use dbx_core::persistence::task_history::{+ TaskRunDetail, TaskRunItemsPage, TaskRunItemsQuery, TaskRunListQuery, TaskRunPage,+};++#[tauri::command]+pub async fn load_task_runs(state: State<'_, Arc<AppState>>, query: TaskRunListQuery) -> Result<TaskRunPage, String> {+ state.storage.list_task_runs(query).await.map_err(|error| error.code().to_string())+}++#[tauri::command]+pub async fn load_task_run(state: State<'_, Arc<AppState>>, run_id: String) -> Result<Option<TaskRunDetail>, String> {+ state.storage.get_task_run_detail(&run_id).await.map_err(|error| error.code().to_string())+}++#[tauri::command]+pub async fn load_task_run_items(+ state: State<'_, Arc<AppState>>,+ run_id: String,+ query: TaskRunItemsQuery,+) -> Result<TaskRunItemsPage, String> {+ state.storage.list_task_run_items(&run_id, query).await.map_err(|error| error.code().to_string())+}diff --git a/src-tauri/src/commands/transfer.rs b/src-tauri/src/commands/transfer.rsindex 4bb090f05b..3fa47bab80 100644--- a/src-tauri/src/commands/transfer.rs+++ b/src-tauri/src/commands/transfer.rs@@ -5,6 +5,9 @@ use crate::commands::connection::{ensure_connection_writable, AppState};// Re-export types and functions used by other modulesuse dbx_core::models::connection::DatabaseType;+use dbx_core::persistence::task_history::{+ TaskHistoryStorageError, TaskItemStatus, TaskLifecycleOwner, TransferTaskJournal,+};pub use dbx_core::transfer::{get_db_type, TransferOwnershipPreview, TransferProgress, TransferRequest, TransferStatus,};@@ -13,6 +16,13 @@ fn emit_progress(app: &AppHandle, progress: TransferProgress) {let _ = app.emit("transfer-progress", progress);}+async fn emit_terminal_progress(app: &AppHandle, history: Option<&TransferTaskJournal>, progress: TransferProgress) {+ if let Some(history) = history {+ history.finish(&progress).await;+ }+ emit_progress(app, progress);+}+#[tauri::command]pub async fn start_transfer(app: AppHandle,@@ -70,6 +80,12 @@ pub async fn start_transfer(dbx_core::transfer::ensure_transfer_source_types_supported(&state, &request, &source_pool_key).await?;+ let history = match TransferTaskJournal::accept(&state.storage, &state, &request, TaskLifecycleOwner::Tauri).await {+ Ok(history) => history,+ Err(TaskHistoryStorageError::RunIdConflict) => return Err("TRANSFER_RUN_ID_CONFLICT".to_string()),+ Err(error) => return Err(error.code().to_string()),+ };+tokio::spawn(async move {// Sort tables by FK dependency so referenced tables are transferred first,// and keep the foreign key metadata fetched along the way — MySQL-family@@ -157,8 +173,9 @@ pub async fn start_transfer({Ok(names) => Some(names),Err(e) if e == "Cancelled" => {- emit_progress(+ emit_terminal_progress(&app,+ history.as_ref(),TransferProgress {transfer_id: transfer_id.clone(),table: "rename pre-pass".to_string(),@@ -170,13 +187,15 @@ pub async fn start_transfer(error: None,terminal: true,},- );+ )+ .await;dbx_core::transfer::clear_cancelled(&transfer_id).await;return;}Err(e) => {- emit_progress(+ emit_terminal_progress(&app,+ history.as_ref(),TransferProgress {transfer_id: transfer_id.clone(),table: "rename pre-pass".to_string(),@@ -188,7 +207,8 @@ pub async fn start_transfer(error: Some(e),terminal: true,},- );+ )+ .await;dbx_core::transfer::clear_cancelled(&transfer_id).await;return;}@@ -215,8 +235,9 @@ pub async fn start_transfer({Ok(()) => {}Err(e) if e == "Cancelled" => {- emit_progress(+ emit_terminal_progress(&app,+ history.as_ref(),TransferProgress {transfer_id: transfer_id.clone(),table: "schema dependencies".to_string(),@@ -228,13 +249,15 @@ pub async fn start_transfer(error: None,terminal: true,},- );+ )+ .await;dbx_core::transfer::clear_cancelled(&transfer_id).await;return;}Err(e) => {- emit_progress(+ emit_terminal_progress(&app,+ history.as_ref(),TransferProgress {transfer_id: transfer_id.clone(),table: "schema dependencies".to_string(),@@ -246,7 +269,8 @@ pub async fn start_transfer(error: Some(e),terminal: true,},- );+ )+ .await;dbx_core::transfer::clear_cancelled(&transfer_id).await;return;}@@ -254,8 +278,9 @@ pub async fn start_transfer(}for (i, table) in sorted_tables.iter().enumerate() {if dbx_core::transfer::is_cancelled(&transfer_id).await {- emit_progress(+ emit_terminal_progress(&app,+ history.as_ref(),TransferProgress {transfer_id: transfer_id.clone(),table: table.clone(),@@ -267,14 +292,23 @@ pub async fn start_transfer(error: None,terminal: true,},- );+ )+ .await;dbx_core::transfer::clear_cancelled(&transfer_id).await;return;}log::info!("[transfer] table {}/{}: {}", i + 1, total_tables, table);-- match dbx_core::transfer::transfer_table(+ let history_item_index =+ history.as_ref().and_then(|journal| journal.item_index_for_table(table)).unwrap_or(i);+ if let Some(journal) = history.as_ref() {+ journal.start_table(history_item_index).await;+ }+ let mut source_row_count = None;+ let mut moved_row_count = None;+ let history_for_progress = history.as_ref();+ let history_for_count = history.as_ref();+ let result = dbx_core::transfer::transfer_table_with_result(&state,&request,table,@@ -289,12 +323,32 @@ pub async fn start_transfer(|progress| {last_rows_transferred = progress.rows_transferred;last_total_rows = progress.total_rows;+ moved_row_count = Some(progress.rows_transferred);+ if let Some(journal) = history_for_progress {+ journal.observe_table_progress(history_item_index, progress.rows_transferred);+ }emit_progress(&app, progress);},+ |source_count| {+ source_row_count = source_count;+ if let Some(journal) = history_for_count {+ journal.observe_source_count(history_item_index, source_count);+ }+ },)- .await- {- Ok(rows) => {+ .await;+ match result {+ Ok(result) => {+ if let Some(journal) = history.as_ref() {+ journal+ .finish_table(+ history_item_index,+ TaskItemStatus::Succeeded,+ result.source_row_count,+ Some(result.moved_rows),+ )+ .await;+ }emit_progress(&app,TransferProgress {@@ -302,8 +356,8 @@ pub async fn start_transfer(table: table.clone(),table_index: i,total_tables,- rows_transferred: rows,- total_rows: last_total_rows.or(Some(rows)),+ rows_transferred: result.moved_rows,+ total_rows: last_total_rows.or(Some(result.moved_rows)),status: TransferStatus::TableDone,error: None,terminal: false,@@ -312,23 +366,40 @@ pub async fn start_transfer(}Err(e) => {if e == "Cancelled" {- emit_progress(+ if let Some(journal) = history.as_ref() {+ journal+ .finish_table(+ history_item_index,+ TaskItemStatus::Cancelled,+ source_row_count,+ moved_row_count,+ )+ .await;+ }+ emit_terminal_progress(&app,+ history.as_ref(),TransferProgress {transfer_id: transfer_id.clone(),table: table.clone(),table_index: i,total_tables,- rows_transferred: last_rows_transferred,- total_rows: last_total_rows,+ rows_transferred: 0,+ total_rows: None,status: TransferStatus::Cancelled,error: None,terminal: true,},- );+ )+ .await;dbx_core::transfer::clear_cancelled(&transfer_id).await;return;}+ if let Some(journal) = history.as_ref() {+ journal+ .finish_table(history_item_index, TaskItemStatus::Failed, source_row_count, moved_row_count)+ .await;+ }failed_tables.push(table.clone());emit_progress(&app,@@ -385,11 +456,18 @@ pub async fn start_transfer(.await{Ok(outcome) => {+ if let Some(journal) = history.as_ref() {+ journal.record_object_outcome(&outcome).await;+ }object_outcome = outcome;}Err(e) if e == "Cancelled" => {- emit_progress(+ if let Some(journal) = history.as_ref() {+ journal.record_schema_objects_error(true).await;+ }+ emit_terminal_progress(&app,+ history.as_ref(),TransferProgress {transfer_id: transfer_id.clone(),table: "schema objects".to_string(),@@ -401,11 +479,15 @@ pub async fn start_transfer(error: None,terminal: true,},- );+ )+ .await;dbx_core::transfer::clear_cancelled(&transfer_id).await;return;}Err(e) => {+ if let Some(journal) = history.as_ref() {+ journal.record_schema_objects_error(false).await;+ }failed_tables.push("schema objects".to_string());emit_progress(&app,@@ -461,8 +543,9 @@ pub async fn start_transfer(String::new()};- emit_progress(+ emit_terminal_progress(&app,+ history.as_ref(),TransferProgress {transfer_id: transfer_id.clone(),table: String::new(),@@ -487,7 +570,8 @@ pub async fn start_transfer(},terminal: true,},- );+ )+ .await;dbx_core::transfer::clear_cancelled(&transfer_id).await;});diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rsindex 54429caf3e..24e84eef3d 100644--- a/src-tauri/src/lib.rs+++ b/src-tauri/src/lib.rs@@ -2583,6 +2583,9 @@ pub fn run() {commands::history::clear_history_by_source,commands::history::cleanup_mcp_history_retention,commands::history::delete_history_entry,+ commands::task_history::load_task_runs,+ commands::task_history::load_task_run,+ commands::task_history::load_task_run_items,commands::mcp::check_mcp_server_status,commands::mcp::install_mcp_server,commands::mcp::install_native_mcp_server,