mod common;
mod mysql;
mod postgres;
mod sqlite;
use anyhow::Result;
use clap::{Args, Subcommand};
use rustf::config::AppConfig;
use std::path::{Path, PathBuf};
use self::{mysql::MySqlIntrospector, postgres::PostgresIntrospector, sqlite::SqliteIntrospector};
use async_trait::async_trait;
pub use common::*;
#[async_trait]
pub trait DatabaseIntrospector: Send + Sync {
async fn list_tables(&self, metadata: bool) -> Result<Vec<TableInfo>>;
async fn describe_table(&self, table_name: &str) -> Result<TableDescription>;
async fn generate_schemas(
&self,
output_dir: &PathBuf,
force: bool,
filter_tables: &[String],
) -> Result<()>;
async fn generate_meta_yaml(&self) -> Result<String>;
async fn get_database_name(&self) -> Result<String>;
async fn export_data(&self, query: &str, format: &str) -> Result<String>;
}
async fn create_introspector(database_url: &str) -> Result<Box<dyn DatabaseIntrospector>> {
if database_url.starts_with("mysql://") {
Ok(Box::new(MySqlIntrospector::new(database_url).await?))
} else if database_url.starts_with("postgresql://") || database_url.starts_with("postgres://") {
Ok(Box::new(PostgresIntrospector::new(database_url).await?))
} else if database_url.starts_with("sqlite://") {
Ok(Box::new(SqliteIntrospector::new(database_url).await?))
} else {
anyhow::bail!("Unsupported database type. Supported: MySQL, PostgreSQL, SQLite")
}
}
#[derive(Debug, Args)]
pub struct DbCommand {
#[command(subcommand)]
pub action: DbAction,
}
#[derive(Debug, Subcommand)]
pub enum DbAction {
Describe {
table_name: String,
#[arg(long)]
connection: Option<String>,
#[arg(long, default_value = "table")]
format: String,
},
DiffSchema {
schema_file: PathBuf,
#[arg(long)]
connection: Option<String>,
},
ExportData {
table_name: String,
#[arg(long)]
connection: Option<String>,
#[arg(long, default_value = "json")]
format: String,
#[arg(long)]
limit: Option<u32>,
#[arg(short, long)]
output: Option<PathBuf>,
},
GenerateSchema {
#[arg(long)]
connection: Option<String>,
#[arg(long)]
force: bool,
#[arg(short, long, default_value = "schemas")]
output: PathBuf,
#[arg(long)]
tables: Vec<String>,
#[arg(long)]
no_sql: bool,
},
DumpSchema {
#[arg(long)]
connection: Option<String>,
#[arg(short, long, default_value = "schemas/_database_dump.sql")]
output: PathBuf,
},
ListTables {
#[arg(long)]
connection: Option<String>,
#[arg(long, default_value = "table")]
format: String,
#[arg(long)]
metadata: bool,
},
TestConnection {
#[arg(long)]
connection: Option<String>,
},
}
impl DbCommand {
pub async fn execute(self, project_path: PathBuf) -> Result<()> {
match self.action {
DbAction::Describe {
table_name,
connection,
format,
} => describe_table(project_path, table_name, connection, format).await,
DbAction::DiffSchema {
schema_file,
connection,
} => diff_schema(project_path, schema_file, connection).await,
DbAction::ExportData {
table_name,
connection,
format,
limit,
output,
} => export_data(project_path, table_name, format, output, connection, limit).await,
DbAction::GenerateSchema {
connection,
force,
output,
tables,
no_sql,
} => generate_schema(project_path, output, connection, force, tables, no_sql).await,
DbAction::DumpSchema { connection, output } => {
dump_schema(project_path, output, connection).await
}
DbAction::ListTables {
connection,
format,
metadata,
} => list_tables(project_path, connection, metadata, format).await,
DbAction::TestConnection { connection } => {
test_connection(project_path, connection).await
}
}
}
}
async fn load_cli_config(project_path: &PathBuf) -> Result<AppConfig> {
let config = AppConfig::load_with_base_dir(project_path)?;
log::debug!("Configuration loaded and merged successfully");
Ok(config)
}
async fn get_database_url(project_path: PathBuf, connection: Option<String>) -> Result<String> {
let config = load_cli_config(&project_path).await?;
let database_url = connection.unwrap_or_else(|| {
std::env::var("DATABASE_URL").unwrap_or_else(|_| config.database.url.unwrap_or_default())
});
if database_url.is_empty() {
anyhow::bail!(
"No database URL found. Set DATABASE_URL environment variable or configure in config.toml/config.dev.toml"
);
}
Ok(database_url)
}
async fn test_connection(project_path: PathBuf, connection: Option<String>) -> Result<()> {
println!("🔌 Testing database connection...");
let database_url = get_database_url(project_path, connection).await?;
let masked_url = if database_url.contains("://") {
let parts: Vec<&str> = database_url.split("://").collect();
if parts.len() == 2 {
let protocol = parts[0];
let rest = parts[1];
if let Some(at_pos) = rest.rfind('@') {
let host_part = &rest[at_pos..];
format!("{}://***{}", protocol, host_part)
} else {
format!("{}://***", protocol)
}
} else {
"***".to_string()
}
} else {
"***".to_string()
};
println!("📍 Connecting to: {}", masked_url);
let introspector = create_introspector(&database_url).await?;
let db_name = introspector.get_database_name().await?;
println!("✅ Connection successful!");
println!("📊 Database: {}", db_name);
let tables = introspector.list_tables(false).await?;
println!("📋 Tables found: {}", tables.len());
Ok(())
}
async fn list_tables(
project_path: PathBuf,
connection: Option<String>,
metadata: bool,
format: String,
) -> Result<()> {
let database_url = get_database_url(project_path, connection).await?;
let introspector = create_introspector(&database_url).await?;
let tables = introspector.list_tables(metadata).await?;
match format.as_str() {
"json" => {
println!("{}", serde_json::to_string_pretty(&tables)?);
}
"table" | _ => {
if tables.is_empty() {
println!("No tables found in the database.");
} else {
println!("📋 Tables in database:\n");
println!(
"{:<30} {:<15} {:<15} {:<15}",
"Table Name", "Type", "Rows", "Size (MB)"
);
println!("{:-<75}", "");
for table in tables {
let row_count = table
.row_count
.map(|c| c.to_string())
.unwrap_or_else(|| "-".to_string());
let size = table
.size_bytes
.map(|s| format!("{:.2}", s as f64 / 1_048_576.0))
.unwrap_or_else(|| "-".to_string());
println!(
"{:<30} {:<15} {:<15} {:<15}",
table.name, table.table_type, row_count, size
);
}
}
}
}
Ok(())
}
async fn describe_table(
project_path: PathBuf,
table_name: String,
connection: Option<String>,
format: String,
) -> Result<()> {
let database_url = get_database_url(project_path, connection).await?;
let introspector = create_introspector(&database_url).await?;
let description = introspector.describe_table(&table_name).await?;
match format.as_str() {
"json" => {
println!("{}", serde_json::to_string_pretty(&description)?);
}
"table" | _ => {
println!("📊 Table: {}\n", description.table.name);
if let Some(comment) = &description.table.comment {
if !comment.is_empty() {
println!("📝 Description: {}\n", comment);
}
}
println!("📋 Columns:");
println!(
"{:<25} {:<20} {:<10} {:<10} {:<15}",
"Column", "Type", "Nullable", "Key", "Default"
);
println!("{:-<80}", "");
for column in &description.columns {
let key_info = if column.is_primary_key {
"PRI"
} else if column.is_foreign_key {
"FK"
} else if column.is_unique {
"UNI"
} else {
""
};
let nullable = if column.is_nullable { "YES" } else { "NO" };
let default = column.default_value.as_deref().unwrap_or("-");
println!(
"{:<25} {:<20} {:<10} {:<10} {:<15}",
column.name, column.data_type, nullable, key_info, default
);
}
if !description.indexes.is_empty() {
println!("\n📑 Indexes:");
for index in &description.indexes {
let unique = if index.is_unique { "UNIQUE" } else { "" };
println!(
" - {} ({}) {}",
index.name,
index.columns.join(", "),
unique
);
}
}
if !description.triggers.is_empty() {
println!("\n⚡ Triggers:");
for trigger in &description.triggers {
println!(
" - {} ({} {} FOR EACH {})",
trigger.name, trigger.timing, trigger.event, trigger.for_each
);
}
}
}
}
Ok(())
}
async fn generate_schema(
project_path: PathBuf,
output: PathBuf,
connection: Option<String>,
force: bool,
tables: Vec<String>,
no_sql: bool,
) -> Result<()> {
println!("🚀 Generating RustF YAML schemas from database...");
println!("📂 Project: {:?}", project_path);
println!("📁 Output: {:?}", output);
let database_url = get_database_url(project_path.clone(), connection.clone()).await?;
let masked_url = if database_url.contains("://") {
let parts: Vec<&str> = database_url.split("://").collect();
if parts.len() == 2 {
let protocol = parts[0];
let rest = parts[1];
if let Some(at_pos) = rest.rfind('@') {
let host_part = &rest[at_pos..];
format!("{}://***{}", protocol, host_part)
} else {
format!("{}://***", protocol)
}
} else {
"***".to_string()
}
} else {
"***".to_string()
};
println!("📍 Database: {}", masked_url);
if force && output.exists() && !crate::utils::backup::is_empty_directory(&output)? {
use crate::utils::backup::BackupManager;
let backup_manager = BackupManager::new()?;
backup_manager.backup_directory(&output, "schemas")?;
}
if !output.exists() {
tokio::fs::create_dir_all(&output).await?;
println!("📁 Created output directory: {:?}", output);
}
let introspector = create_introspector(&database_url).await?;
introspector
.generate_schemas(&output, force, &tables)
.await?;
println!("🎉 Schema generation completed successfully!");
if !no_sql {
let sql_output = output.join("_database_dump.sql");
match run_dump_to_file(&database_url, &sql_output).await {
Ok(()) => {
println!("🗄️ Dumped DDL to: {:?}", sql_output);
}
Err(e) => {
eprintln!("⚠️ SQL dump skipped: {}", e);
eprintln!(" Pass --no-sql to silence this, or run `rustf-cli db dump-schema` separately.");
}
}
}
Ok(())
}
async fn dump_schema(
project_path: PathBuf,
output: PathBuf,
connection: Option<String>,
) -> Result<()> {
let resolved = if output.is_absolute() {
output.clone()
} else {
project_path.join(&output)
};
println!("🗄️ Dumping database DDL to {:?}", resolved);
let database_url = get_database_url(project_path, connection).await?;
run_dump_to_file(&database_url, &resolved).await?;
println!("✅ Dump complete.");
Ok(())
}
async fn run_dump_to_file(database_url: &str, output: &Path) -> Result<()> {
use std::process::Stdio;
use tokio::io::AsyncWriteExt;
if let Some(parent) = output.parent() {
if !parent.as_os_str().is_empty() && !parent.exists() {
tokio::fs::create_dir_all(parent).await?;
}
}
let spec = DumpCommand::from_url(database_url)?;
log::debug!(
"Invoking {} with {} args (secrets redacted)",
spec.program,
spec.args.len()
);
let mut cmd = tokio::process::Command::new(&spec.program);
cmd.args(&spec.args);
for (k, v) in &spec.env {
cmd.env(k, v);
}
cmd.stdout(Stdio::piped()).stderr(Stdio::piped());
let mut child = cmd.spawn().map_err(|e| {
if e.kind() == std::io::ErrorKind::NotFound {
anyhow::anyhow!(
"`{}` not found on PATH. Install it to enable SQL dumps \
(brew install {} / apt install {} / equivalent).",
spec.program,
spec.install_hint,
spec.install_hint
)
} else {
anyhow::anyhow!("Failed to spawn `{}`: {}", spec.program, e)
}
})?;
let stdout = child.stdout.take().expect("stdout piped");
let stderr = child.stderr.take().expect("stderr piped");
let output_path = output.to_path_buf();
let write_task = tokio::spawn(async move {
let mut reader = stdout;
let mut file = tokio::fs::File::create(&output_path).await?;
tokio::io::copy(&mut reader, &mut file).await?;
file.flush().await?;
Ok::<(), std::io::Error>(())
});
let stderr_task = tokio::spawn(async move {
use tokio::io::AsyncReadExt;
let mut reader = stderr;
let mut buf = Vec::new();
let _ = reader.read_to_end(&mut buf).await;
buf
});
let status = child.wait().await?;
let stderr_bytes = stderr_task.await.unwrap_or_default();
write_task.await??;
let dump_size = tokio::fs::metadata(output)
.await
.map(|m| m.len())
.unwrap_or(0);
if !status.success() {
let stderr_text = String::from_utf8_lossy(&stderr_bytes);
if dump_size == 0 {
let _ = tokio::fs::remove_file(output).await;
anyhow::bail!(
"`{}` exited with status {} without producing output: {}",
spec.program,
status.code().map(|c| c.to_string()).unwrap_or_else(|| "signal".into()),
stderr_text.trim()
);
}
let stderr_snippet: String = stderr_text
.lines()
.take(5)
.collect::<Vec<_>>()
.join("\n ");
eprintln!(
"⚠️ `{}` exited with status {} but wrote {} bytes — keeping partial dump.",
spec.program,
status.code().map(|c| c.to_string()).unwrap_or_else(|| "signal".into()),
dump_size
);
eprintln!(" First errors:\n {}", stderr_snippet);
}
Ok(())
}
struct DumpCommand {
program: &'static str,
args: Vec<String>,
env: Vec<(&'static str, String)>,
install_hint: &'static str,
}
impl DumpCommand {
fn from_url(database_url: &str) -> Result<Self> {
if database_url.starts_with("mysql://") {
Self::mysql(database_url)
} else if database_url.starts_with("postgres://") || database_url.starts_with("postgresql://") {
Self::postgres(database_url)
} else if database_url.starts_with("sqlite:") {
Self::sqlite(database_url)
} else {
anyhow::bail!(
"Unsupported database URL for SQL dump: expected mysql://, postgresql://, or sqlite:"
)
}
}
fn mysql(database_url: &str) -> Result<Self> {
let parsed = url::Url::parse(database_url)
.map_err(|e| anyhow::anyhow!("Invalid MySQL URL: {}", e))?;
let host = parsed.host_str().unwrap_or("localhost").to_string();
let port = parsed.port().unwrap_or(3306).to_string();
let user = parsed.username();
if user.is_empty() {
anyhow::bail!("MySQL URL missing user");
}
let user = user.to_string();
let db_name = parsed.path().trim_start_matches('/');
if db_name.is_empty() {
anyhow::bail!("MySQL URL missing database name");
}
let mut args: Vec<String> = vec![
"--no-data".into(),
"--skip-comments".into(),
"--skip-dump-date".into(),
"--skip-add-locks".into(),
"--skip-lock-tables".into(),
"--single-transaction".into(),
"--skip-set-charset".into(),
"--compact".into(),
"--force".into(),
format!("--host={}", host),
format!("--port={}", port),
format!("--user={}", user),
db_name.to_string(),
];
args.insert(0, "--routines".into());
args.insert(0, "--triggers".into());
let mut env: Vec<(&'static str, String)> = Vec::new();
if let Some(pw) = parsed.password() {
env.push(("MYSQL_PWD", pw.to_string()));
}
Ok(Self {
program: "mysqldump",
args,
env,
install_hint: "mysql-client",
})
}
fn postgres(database_url: &str) -> Result<Self> {
Ok(Self {
program: "pg_dump",
args: vec![
"--schema-only".into(),
"--no-owner".into(),
"--no-privileges".into(),
"--no-comments".into(),
database_url.to_string(),
],
env: Vec::new(),
install_hint: "postgresql-client",
})
}
fn sqlite(database_url: &str) -> Result<Self> {
let path = database_url
.trim_start_matches("sqlite:")
.trim_start_matches("//");
if path.is_empty() || path == ":memory:" {
anyhow::bail!("Cannot dump in-memory SQLite database");
}
Ok(Self {
program: "sqlite3",
args: vec![path.to_string(), ".schema".into()],
env: Vec::new(),
install_hint: "sqlite3",
})
}
}
async fn diff_schema(
_project_path: PathBuf,
_schema_file: PathBuf,
_connection: Option<String>,
) -> Result<()> {
println!("⚠️ Schema diff functionality not yet implemented");
Ok(())
}
async fn export_data(
project_path: PathBuf,
table_name: String,
format: String,
output: Option<PathBuf>,
connection: Option<String>,
limit: Option<u32>,
) -> Result<()> {
let database_url = get_database_url(project_path, connection).await?;
let introspector = create_introspector(&database_url).await?;
let query = if let Some(limit) = limit {
format!("SELECT * FROM {} LIMIT {}", table_name, limit)
} else {
format!("SELECT * FROM {}", table_name)
};
let data = introspector.export_data(&query, &format).await?;
if let Some(output_file) = output {
tokio::fs::write(output_file, data).await?;
println!("✅ Data exported successfully");
} else {
println!("{}", data);
}
Ok(())
}