use std::path::{Path, PathBuf}; use std::sync::Arc; use axum::extract::{Multipart, Path as AxumPath, State}; use axum::response::sse::{Event, Sse}; use axum::Json; use dbx_core::query; use dbx_core::sql; use dbx_core::sql::{SqlFileImportStatement, SqlFileImportStatementKind}; use futures::stream::Stream; use serde::Deserialize; use crate::error::AppError; use crate::state::WebState; #[derive(Deserialize)] #[serde(rename_all = "camelCase")] pub struct SqlFileExecuteRequest { pub execution_id: String, pub connection_id: String, pub database: String, pub file_path: String, pub continue_on_error: bool, } #[derive(Deserialize)] #[serde(rename_all = "camelCase")] pub struct SqlFileExecuteWrapper { pub request: SqlFileExecuteRequest, } #[derive(Deserialize)] #[serde(rename_all = "camelCase")] pub struct CancelSqlFileRequest { pub execution_id: String, } pub async fn preview_sql_file( State(state): State>, mut multipart: Multipart, ) -> Result, AppError> { let tmp_dir = state.data_dir.join("tmp"); std::fs::create_dir_all(&tmp_dir).map_err(|e| AppError(e.to_string()))?; if let Some(field) = multipart.next_field().await.map_err(|e| AppError(e.to_string()))? { let file_name = field.file_name().unwrap_or("upload.sql").to_string(); let data = field.bytes().await.map_err(|e| AppError(e.to_string()))?; let file_path = safe_uploaded_sql_path(&tmp_dir, &file_name)?; std::fs::write(&file_path, &data).map_err(|e| AppError(e.to_string()))?; let size_bytes = data.len() as u64; let content = sql::decode_sql_file_bytes(&data).map_err(AppError)?; let preview: String = content.chars().take(20_000).collect(); return Ok(Json(serde_json::json!({ "fileName": file_name, "filePath": file_path.to_string_lossy(), "sizeBytes": size_bytes, "preview": preview, }))); } Err(AppError("No file uploaded".to_string())) } pub async fn execute_sql_file( State(state): State>, Json(body): Json, ) -> Result, AppError> { let req = body.request; let execution_id = req.execution_id.clone(); let (tx, _) = tokio::sync::broadcast::channel::(256); state.sse_channels.write().await.insert(execution_id.clone(), tx.clone()); let app = state.app.clone(); let state_clone = state.clone(); let file_path = validated_uploaded_sql_path(&state.data_dir, &req.file_path)?; tokio::spawn(async move { match std::fs::metadata(&file_path) { Ok(meta) if meta.len() > 200 * 1024 * 1024 => { let progress = dbx_core::sql::SqlFileProgress { execution_id: req.execution_id.clone(), status: dbx_core::sql::SqlFileStatus::Error, statement_index: 0, success_count: 0, failure_count: 0, affected_rows: 0, elapsed_ms: 0, statement_summary: String::new(), error: Some(format!("File too large: {} bytes (max {} bytes)", meta.len(), 200 * 1024 * 1024)), }; if let Ok(json) = serde_json::to_string(&progress) { let _ = tx.send(json); } return; } Err(e) => { let progress = dbx_core::sql::SqlFileProgress { execution_id: req.execution_id.clone(), status: dbx_core::sql::SqlFileStatus::Error, statement_index: 0, success_count: 0, failure_count: 0, affected_rows: 0, elapsed_ms: 0, statement_summary: String::new(), error: Some(e.to_string()), }; if let Ok(json) = serde_json::to_string(&progress) { let _ = tx.send(json); } return; } _ => {} } let file_content = match std::fs::read(&file_path).and_then(|bytes| { sql::decode_sql_file_bytes(&bytes) .map_err(|message| std::io::Error::new(std::io::ErrorKind::InvalidData, message)) }) { Ok(content) => content, Err(e) => { let progress = dbx_core::sql::SqlFileProgress { execution_id: req.execution_id.clone(), status: dbx_core::sql::SqlFileStatus::Error, statement_index: 0, success_count: 0, failure_count: 0, affected_rows: 0, elapsed_ms: 0, statement_summary: String::new(), error: Some(e.to_string()), }; if let Ok(json) = serde_json::to_string(&progress) { let _ = tx.send(json); } return; } }; // Send started let started = dbx_core::sql::SqlFileProgress { execution_id: req.execution_id.clone(), status: dbx_core::sql::SqlFileStatus::Started, statement_index: 0, success_count: 0, failure_count: 0, affected_rows: 0, elapsed_ms: 0, statement_summary: String::new(), error: None, }; if let Ok(json) = serde_json::to_string(&started) { let _ = tx.send(json); } let import_target = { let configs = app.configs.read().await; configs.get(&req.connection_id).map(|config| (config.db_type, config.driver_profile.clone())) }; let statements = import_target .as_ref() .map(|(db_type, _)| sql::split_sql_statements_for_database(&file_content, *db_type)) .unwrap_or_else(|| sql::split_sql_statements(&file_content)); let planned_statements = sql::optimize_sql_file_import_statements( &statements, import_target.as_ref().map(|(db_type, _)| *db_type), import_target.as_ref().and_then(|(_, driver_profile)| driver_profile.as_deref()), ); let start = std::time::Instant::now(); let mut success_count = 0usize; let mut failure_count = 0usize; let mut total_affected: u64 = 0; let mut statement_index = 0usize; for planned_statement in planned_statements { let next_statement_index = statement_index + planned_statement.source_statement_count; let summary = sql::statement_summary(&planned_statement.sql); // Send running let running = dbx_core::sql::SqlFileProgress { execution_id: req.execution_id.clone(), status: dbx_core::sql::SqlFileStatus::Running, statement_index: next_statement_index, success_count, failure_count, affected_rows: total_affected, elapsed_ms: start.elapsed().as_millis(), statement_summary: summary.clone(), error: None, }; if let Ok(json) = serde_json::to_string(&running) { let _ = tx.send(json); } if planned_statement.kind == SqlFileImportStatementKind::Skip { success_count += planned_statement.source_statement_count; let done = dbx_core::sql::SqlFileProgress { execution_id: req.execution_id.clone(), status: dbx_core::sql::SqlFileStatus::StatementDone, statement_index: next_statement_index, success_count, failure_count, affected_rows: total_affected, elapsed_ms: start.elapsed().as_millis(), statement_summary: summary, error: None, }; if let Ok(json) = serde_json::to_string(&done) { let _ = tx.send(json); } statement_index = next_statement_index; continue; } match query::execute_sql_statement( &app, &req.connection_id, &req.database, &planned_statement.sql, None, None, ) .await { Ok(result) => { success_count += planned_statement.source_statement_count; total_affected += result.affected_rows; let done = dbx_core::sql::SqlFileProgress { execution_id: req.execution_id.clone(), status: dbx_core::sql::SqlFileStatus::StatementDone, statement_index: next_statement_index, success_count, failure_count, affected_rows: total_affected, elapsed_ms: start.elapsed().as_millis(), statement_summary: summary, error: None, }; if let Ok(json) = serde_json::to_string(&done) { let _ = tx.send(json); } } Err(e) => { let stopped = execute_web_merged_statement_fallback( &app, &req, &tx, start, statement_index + 1, &planned_statement, &mut success_count, &mut failure_count, &mut total_affected, e, ) .await; if stopped || !req.continue_on_error { break; } } } statement_index = next_statement_index; } // Send final done let final_done = dbx_core::sql::SqlFileProgress { execution_id: req.execution_id.clone(), status: dbx_core::sql::SqlFileStatus::Done, statement_index, success_count, failure_count, affected_rows: total_affected, elapsed_ms: start.elapsed().as_millis(), statement_summary: String::new(), error: None, }; if let Ok(json) = serde_json::to_string(&final_done) { let _ = tx.send(json); } state_clone.remove_sse_channel(&req.execution_id).await; }); Ok(Json(serde_json::json!({ "executionId": execution_id }))) } async fn execute_web_merged_statement_fallback( app: &Arc, req: &SqlFileExecuteRequest, tx: &tokio::sync::broadcast::Sender, start: std::time::Instant, first_statement_index: usize, statement: &SqlFileImportStatement, success_count: &mut usize, failure_count: &mut usize, total_affected: &mut u64, batch_error: String, ) -> bool { if statement.source_statement_count <= 1 { let summary = sql::statement_summary(&statement.sql); *failure_count += 1; let failed = dbx_core::sql::SqlFileProgress { execution_id: req.execution_id.clone(), status: dbx_core::sql::SqlFileStatus::StatementFailed, statement_index: first_statement_index, success_count: *success_count, failure_count: *failure_count, affected_rows: *total_affected, elapsed_ms: start.elapsed().as_millis(), statement_summary: summary, error: Some(batch_error), }; if let Ok(json) = serde_json::to_string(&failed) { let _ = tx.send(json); } return false; } for (offset, source_sql) in statement.source_sqls.iter().enumerate() { let statement_index = first_statement_index + offset; let summary = sql::statement_summary(source_sql); let running = dbx_core::sql::SqlFileProgress { execution_id: req.execution_id.clone(), status: dbx_core::sql::SqlFileStatus::Running, statement_index, success_count: *success_count, failure_count: *failure_count, affected_rows: *total_affected, elapsed_ms: start.elapsed().as_millis(), statement_summary: summary.clone(), error: None, }; if let Ok(json) = serde_json::to_string(&running) { let _ = tx.send(json); } match query::execute_sql_statement(app, &req.connection_id, &req.database, source_sql, None, None).await { Ok(result) => { *success_count += 1; *total_affected += result.affected_rows; let done = dbx_core::sql::SqlFileProgress { execution_id: req.execution_id.clone(), status: dbx_core::sql::SqlFileStatus::StatementDone, statement_index, success_count: *success_count, failure_count: *failure_count, affected_rows: *total_affected, elapsed_ms: start.elapsed().as_millis(), statement_summary: summary, error: None, }; if let Ok(json) = serde_json::to_string(&done) { let _ = tx.send(json); } } Err(error) => { *failure_count += 1; let failed = dbx_core::sql::SqlFileProgress { execution_id: req.execution_id.clone(), status: dbx_core::sql::SqlFileStatus::StatementFailed, statement_index, success_count: *success_count, failure_count: *failure_count, affected_rows: *total_affected, elapsed_ms: start.elapsed().as_millis(), statement_summary: summary, error: Some(error), }; if let Ok(json) = serde_json::to_string(&failed) { let _ = tx.send(json); } if !req.continue_on_error { return true; } } } } false } fn safe_uploaded_sql_path(tmp_dir: &Path, file_name: &str) -> Result { let base_name = file_name.rsplit(|ch| ch == '/' || ch == '\\').find(|part| !part.is_empty()).unwrap_or("upload.sql").trim(); if base_name.is_empty() || base_name == "." || base_name == ".." { return Err(AppError("Invalid SQL file name".to_string())); } Ok(tmp_dir.join(base_name)) } fn validated_uploaded_sql_path(data_dir: &Path, file_path: &str) -> Result { let path = PathBuf::from(file_path); if !path.is_absolute() { return Err(AppError("File path must be absolute".to_string())); } let tmp_dir = data_dir.join("tmp").canonicalize().map_err(|e| AppError(e.to_string()))?; let canonical_path = path.canonicalize().map_err(|e| AppError(e.to_string()))?; if !canonical_path.starts_with(&tmp_dir) { return Err(AppError("File path must be inside the uploaded SQL directory".to_string())); } Ok(canonical_path) } pub async fn sql_file_progress( State(state): State>, AxumPath(execution_id): AxumPath, ) -> Result>>, AppError> { let channels = state.sse_channels.read().await; let tx = channels.get(&execution_id).ok_or_else(|| AppError("Execution not found".to_string()))?; let rx = tx.subscribe(); drop(channels); Ok(crate::sse::sse_from_channel(rx)) } pub async fn cancel_sql_file( State(state): State>, Json(req): Json, ) -> Json { // Remove the channel to stop the execution loop state.sse_channels.write().await.remove(&req.execution_id); Json(serde_json::json!({ "cancelled": true })) } #[cfg(test)] mod tests { use super::{safe_uploaded_sql_path, validated_uploaded_sql_path}; #[test] fn uploaded_sql_path_uses_only_the_file_name() { let data_dir = std::env::temp_dir().join(format!("dbx-web-sql-file-test-{}", uuid::Uuid::new_v4())); let tmp_dir = data_dir.join("tmp"); let path = match safe_uploaded_sql_path(&tmp_dir, "../outside.sql") { Ok(path) => path, Err(error) => panic!("{}", error.0), }; assert_eq!(path, tmp_dir.join("outside.sql")); let _ = std::fs::remove_dir_all(data_dir); } #[test] fn execution_path_must_stay_inside_uploaded_tmp_dir() { let data_dir = std::env::temp_dir().join(format!("dbx-web-sql-file-test-{}", uuid::Uuid::new_v4())); let tmp_dir = data_dir.join("tmp"); std::fs::create_dir_all(&tmp_dir).unwrap(); let outside = data_dir.join("outside.sql"); std::fs::write(&outside, "select 1;").unwrap(); let result = validated_uploaded_sql_path(&data_dir, &outside.to_string_lossy()); assert!(result.is_err()); let _ = std::fs::remove_dir_all(data_dir); } }