pub mod postgres;
pub mod mysql;
pub mod sqlite;
pub mod sql_gen;
use crate::analyzer::OutputFormat;
use clap::{Args, Subcommand};
use rustf_schema::Schema;
use std::path::{Path, PathBuf};
#[derive(Debug, Args)]
pub struct SchemaCommand {
#[command(subcommand)]
pub action: SchemaAction,
}
#[derive(Debug, Subcommand)]
pub enum SchemaAction {
Analyze {
#[arg(short, long, value_enum, default_value = "table")]
format: OutputFormat,
#[arg(short = 's', long, default_value = "schemas")]
path: PathBuf,
},
CheckConsistency {
#[arg(short = 'm', long, default_value = "src/models")]
models_path: PathBuf,
#[arg(short = 'c', long, default_value = "schemas")]
schema_path: PathBuf,
},
Generate {
#[command(subcommand)]
target: GenerateTarget,
},
Validate {
#[arg(long)]
check_generated: bool,
#[arg(short, long, default_value = "schemas")]
path: PathBuf,
},
Watch {
#[arg(long)]
auto_generate: bool,
#[arg(short = 'w', long, default_value = "schemas")]
path: PathBuf,
},
}
#[derive(Debug, Subcommand, Clone)]
pub enum GenerateTarget {
Sql {
#[arg(short = 'o', long, default_value = "sql")]
output: PathBuf,
#[arg(short = 's', long, default_value = "schemas")]
schema_path: PathBuf,
},
Models {
#[arg(long)]
force: bool,
#[arg(short, long, default_value = "src/models")]
output: PathBuf,
#[arg(short = 's', long, default_value = "schemas")]
schema_path: PathBuf,
#[arg(short = 't', long, value_delimiter = ',')]
tables: Option<Vec<String>>,
#[arg(short = 'e', long, value_delimiter = ',')]
exclude: Option<Vec<String>>,
},
}
impl SchemaCommand {
pub async fn execute(self) -> anyhow::Result<()> {
let backend = if let SchemaAction::Generate { ref target } = self.action {
match target {
GenerateTarget::Sql { schema_path, .. } |
GenerateTarget::Models { schema_path, .. } => {
detect_database_backend_from_path(schema_path).await?
}
}
} else if let SchemaAction::Validate { ref path, .. } = self.action {
detect_database_backend_from_path(path).await?
} else {
"Postgres".to_string()
};
match backend.as_str() {
"Postgres" | "PostgreSQL" => {
postgres::execute_schema_command(self).await
}
"MySql" | "MySQL" => {
mysql::execute_schema_command(self).await
}
"Sqlite" | "SQLite" => {
sqlite::execute_schema_command(self).await
}
_ => {
postgres::execute_schema_command(self).await
}
}
}
}
async fn detect_database_backend_from_path(schema_path: &Path) -> anyhow::Result<String> {
let schema = Schema::load_from_directory(schema_path).await?;
Ok(detect_database_backend(&schema))
}
fn detect_database_backend(schema: &Schema) -> String {
if let Some(meta) = &schema.meta {
if let Some(desc) = &meta.description {
if desc.contains("MySQL") || desc.contains("mysql") {
return "MySql".to_string();
} else if desc.contains("SQLite") || desc.contains("sqlite") {
return "Sqlite".to_string();
} else if desc.contains("PostgreSQL") || desc.contains("postgres") {
return "Postgres".to_string();
}
}
}
"Postgres".to_string()
}
pub fn to_pascal_case(s: &str) -> String {
s.split('_')
.map(|word| {
let mut chars = word.chars();
match chars.next() {
None => String::new(),
Some(first) => first.to_uppercase().chain(chars).collect(),
}
})
.collect()
}
pub fn to_screaming_snake_case(s: &str) -> String {
let mut result = String::new();
let mut previous_was_separator = true;
for ch in s.chars() {
if ch.is_ascii_alphanumeric() {
if ch.is_ascii_uppercase() && !previous_was_separator && !result.ends_with('_') {
result.push('_');
}
result.push(ch.to_ascii_uppercase());
previous_was_separator = false;
} else if !result.ends_with('_') && !result.is_empty() {
result.push('_');
previous_was_separator = true;
} else {
previous_was_separator = true;
}
}
let result = result.trim_matches('_').to_string();
let result = if result.is_empty() {
"VALUE".to_string()
} else {
result
};
if result
.chars()
.next()
.map(|ch| ch.is_ascii_digit())
.unwrap_or(false)
{
format!("V_{}", result)
} else {
result
}
}
#[cfg(test)]
mod tests {
use super::to_screaming_snake_case;
#[test]
fn converts_to_screaming_snake_case() {
assert_eq!(to_screaming_snake_case("expired"), "EXPIRED");
assert_eq!(to_screaming_snake_case("in-progress"), "IN_PROGRESS");
assert_eq!(to_screaming_snake_case("two words"), "TWO_WORDS");
assert_eq!(to_screaming_snake_case("statusExpired"), "STATUS_EXPIRED");
assert_eq!(to_screaming_snake_case("2fa_required"), "V_2FA_REQUIRED");
}
}