use anyhow::Result;
use serde::{Deserialize, Serialize};
#[derive(Debug, Serialize, Deserialize)]
pub struct TableInfo {
pub name: String,
pub schema: Option<String>,
pub table_type: String,
pub row_count: Option<i64>,
pub size_bytes: Option<i64>,
pub comment: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ColumnInfo {
pub name: String,
pub data_type: String,
pub column_type: Option<String>, pub postgres_type_name: Option<String>, pub is_nullable: bool,
pub default_value: Option<String>,
pub is_primary_key: bool,
pub is_unique: bool,
pub is_foreign_key: bool,
pub foreign_table: Option<String>,
pub foreign_column: Option<String>,
pub on_delete: Option<String>,
pub on_update: Option<String>,
pub comment: Option<String>,
pub max_length: Option<i32>,
pub numeric_precision: Option<i32>,
pub numeric_scale: Option<i32>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct TableDescription {
pub table: TableInfo,
pub columns: Vec<ColumnInfo>,
pub indexes: Vec<IndexInfo>,
pub constraints: Vec<ConstraintInfo>,
pub triggers: Vec<TriggerInfo>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct IndexInfo {
pub name: String,
pub columns: Vec<String>,
pub is_unique: bool,
pub is_primary: bool,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct ConstraintInfo {
pub name: String,
pub constraint_type: String,
pub columns: Vec<String>,
pub foreign_table: Option<String>,
pub foreign_columns: Option<Vec<String>>,
pub check_expression: Option<String>,
pub on_delete: Option<String>,
pub on_update: Option<String>,
}
#[derive(Debug, Serialize, Deserialize)]
pub struct TriggerInfo {
pub name: String,
pub event: String, pub timing: String, pub for_each: String, pub condition: Option<String>,
pub body: Option<String>,
pub description: Option<String>,
}
#[allow(dead_code)]
#[derive(Debug)]
pub enum DatabaseType {
PostgreSQL,
MySQL,
SQLite,
}
#[allow(dead_code)]
impl DatabaseType {
pub fn from_url(url: &str) -> Result<Self> {
if url.starts_with("postgres://") || url.starts_with("postgresql://") {
Ok(DatabaseType::PostgreSQL)
} else if url.starts_with("mysql://") {
Ok(DatabaseType::MySQL)
} else if url.starts_with("sqlite://") {
Ok(DatabaseType::SQLite)
} else {
anyhow::bail!("Unsupported database URL: {}", url)
}
}
}
pub fn rows_to_csv(headers: &[String], rows: &[serde_json::Value]) -> String {
if headers.is_empty() {
return String::new();
}
let mut lines = Vec::new();
lines.push(
headers
.iter()
.map(|h| escape_csv_field(h))
.collect::<Vec<_>>()
.join(","),
);
for row in rows {
let Some(object) = row.as_object() else {
continue;
};
let line = headers
.iter()
.map(|header| {
let value = object.get(header).cloned().unwrap_or(serde_json::Value::Null);
let string_value = match value {
serde_json::Value::Null => String::new(),
serde_json::Value::String(s) => s,
other => other.to_string(),
};
escape_csv_field(&string_value)
})
.collect::<Vec<_>>()
.join(",");
lines.push(line);
}
lines.join("\n")
}
pub fn escape_csv_field(value: &str) -> String {
if value.contains([',', '"', '\n']) {
format!("\"{}\"", value.replace('"', "\"\""))
} else {
value.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().collect::<String>() + chars.as_str(),
}
})
.collect()
}
pub fn generate_table_ai_context(table_name: &str) -> String {
let name_lower = table_name.to_lowercase();
if name_lower.contains("user") || name_lower.contains("account") {
"User authentication and profile management. Handle passwords securely with bcrypt."
} else if name_lower.contains("auth") || name_lower.contains("session") {
"Authentication and session management. Ensure secure token handling."
} else if name_lower.contains("log") || name_lower.contains("audit") {
"Audit trail and activity logging. Append-only, never update or delete records."
} else if name_lower.contains("config") || name_lower.contains("setting") {
"Application configuration and settings. Cache frequently accessed values."
} else if name_lower.contains("payment") || name_lower.contains("transaction") {
"Financial transactions. Ensure ACID compliance and proper decimal precision."
} else if name_lower.contains("product") || name_lower.contains("item") {
"Product catalog management. Consider caching for frequently accessed items."
} else if name_lower.contains("order") || name_lower.contains("purchase") {
"Order processing and fulfillment. Maintain state consistency."
} else if name_lower.contains("comment") || name_lower.contains("review") {
"User-generated content. Validate and sanitize input."
} else if name_lower.contains("message") || name_lower.contains("notification") {
"Messaging and notifications. Consider queueing for delivery."
} else {
"Database entity for {} management and data storage"
}.to_string().replace("{}", table_name)
}
pub fn generate_field_ai_hint(field_name: &str, field_type: &str, is_foreign_key: bool) -> String {
let name_lower = field_name.to_lowercase();
if is_foreign_key {
return format!("Foreign key reference to {} table", field_name.trim_end_matches("_id"));
}
if name_lower.contains("password") {
"Always store as bcrypt hash. Never store plain passwords!"
} else if name_lower.contains("email") {
"Valid email format required. Used for authentication and communication."
} else if name_lower.contains("phone") || name_lower.contains("mobile") {
"Phone number with international format support"
} else if name_lower.contains("url") || name_lower.contains("link") {
"URL field - validate format and accessibility"
} else if name_lower.contains("token") || name_lower.contains("secret") {
"Sensitive token - store securely and never log"
} else if name_lower.contains("created_at") {
"Record creation timestamp - automatically set on insert"
} else if name_lower.contains("updated_at") {
"Last modification timestamp - automatically updated on change"
} else if name_lower.contains("deleted_at") {
"Soft deletion timestamp - null means active record"
} else if name_lower.contains("is_active") || name_lower.contains("active") {
"Status flag - false indicates soft deletion or deactivation"
} else if name_lower.contains("verified") {
"Verification status flag for validation workflows"
} else if name_lower.contains("expires") {
"Expiration timestamp - check before use"
} else if name_lower.contains("count") || name_lower.contains("quantity") {
"Integer value for counting or quantity tracking"
} else if name_lower.contains("amount") || name_lower.contains("price") {
"Monetary value - use proper decimal precision"
} else if name_lower.contains("status") || name_lower.contains("state") {
"Status indicator - validate against allowed values"
} else if name_lower.contains("description") {
"Detailed description text - supports rich formatting"
} else if name_lower.contains("name") || name_lower.contains("title") {
"Display name for user interface and identification"
} else if name_lower.contains("code") || name_lower.contains("identifier") {
"Unique identifier code - ensure uniqueness constraints"
} else if name_lower.contains("json") || field_type.contains("json") {
"Structured JSON data - validate schema before storage"
} else if field_type.contains("bool") {
"Boolean flag for binary state tracking"
} else if field_type.contains("enum") {
"Enumerated value - validate against allowed options"
} else if field_type.contains("text") {
"Large text field for extended content"
} else if field_type.contains("decimal") {
"Precise decimal number for financial calculations"
} else if field_type.contains("timestamp") || field_type.contains("datetime") {
"Timestamp field for temporal data tracking"
} else if field_type.contains("date") {
return format!("Database field of type {}", field_type);
} else if field_type.contains("int") {
"Integer value for counting or identification"
} else if field_type.contains("varchar") || field_type.contains("string") {
"String field with length constraints"
} else {
return format!("Database field of type {}", field_type);
}.to_string()
}
pub fn escape_yaml_field_name(field_name: &str) -> String {
match field_name {
"type" => "field_type".to_string(),
"enum" => "enum_field".to_string(),
"values" => "values_field".to_string(),
_ => field_name.to_string(),
}
}
pub fn generate_relations_yaml(columns: &[ColumnInfo]) -> String {
let mut yaml = String::new();
let mut belongs_to_relations = Vec::new();
for column in columns {
if column.is_foreign_key {
if let (Some(foreign_table), Some(foreign_column)) = (&column.foreign_table, &column.foreign_column) {
let relation_name = column.name.trim_end_matches("_id");
belongs_to_relations.push((relation_name, foreign_table, &column.name, foreign_column));
}
}
}
if !belongs_to_relations.is_empty() {
yaml.push_str(" belongs_to:\n");
for (name, table, local, foreign) in belongs_to_relations {
yaml.push_str(&format!(" {}:\n", name));
yaml.push_str(&format!(" model: {}\n", to_pascal_case(table)));
yaml.push_str(&format!(" local_field: {}\n", local));
yaml.push_str(&format!(" foreign_field: {}\n", foreign));
yaml.push_str(&format!(" ai: \"Reference to {} for relational data integrity\"\n", table));
}
}
yaml
}
#[cfg(test)]
mod tests {
use super::{escape_csv_field, rows_to_csv};
use serde_json::json;
#[test]
fn escape_csv_field_quotes_only_when_needed() {
assert_eq!(escape_csv_field("plain"), "plain");
assert_eq!(escape_csv_field("a,b"), "\"a,b\"");
assert_eq!(escape_csv_field("say \"hi\""), "\"say \"\"hi\"\"\"");
assert_eq!(escape_csv_field("line\nbreak"), "\"line\nbreak\"");
}
#[test]
fn rows_to_csv_serializes_header_and_typed_values() {
let headers = vec!["id".to_string(), "name".to_string(), "active".to_string()];
let rows = vec![
json!({"id": 1, "name": "Ann", "active": true}),
json!({"id": 2, "name": "a,b", "active": false}),
];
let csv = rows_to_csv(&headers, &rows);
assert_eq!(csv, "id,name,active\n1,Ann,true\n2,\"a,b\",false");
}
#[test]
fn rows_to_csv_empty_headers_yields_empty_string() {
assert!(rows_to_csv(&[], &[json!({"id": 1})]).is_empty());
}
#[test]
fn rows_to_csv_null_renders_as_empty_field() {
let headers = vec!["a".to_string(), "b".to_string()];
let rows = vec![json!({"a": 1, "b": null})];
assert_eq!(rows_to_csv(&headers, &rows), "a,b\n1,");
}
}