use crate::{
ColumnSchema, DatabaseSchema, DatabaseType, ForeignKeySchema, IndexSchema, SeedSchema,
TableSchema, UniqueConstraintSchema,
};
use appstruct_ir::{GeneratedValueIr, OnDeleteIr};
#[must_use]
pub fn initial_migration(schema: &DatabaseSchema) -> String {
let mut statements = vec![generated_header()];
statements.extend(schema.tables.iter().map(create_table));
statements.extend(schema.unique_constraints.iter().map(add_unique_constraint));
statements.extend(schema.indexes.iter().map(add_index));
statements.extend(schema.seeds.iter().map(add_seed));
statements.extend(schema.foreign_keys.iter().map(add_foreign_key));
format!("{}\n", statements.join("\n"))
}
#[must_use]
pub fn create_table(table: &TableSchema) -> String {
let primary_keys = table
.columns
.iter()
.filter(|column| column.primary_key)
.collect::<Vec<_>>();
let inline_primary_key = primary_keys.len() <= 1;
let mut definitions = table
.columns
.iter()
.map(|column| column_definition(column, inline_primary_key))
.collect::<Vec<_>>();
if !inline_primary_key {
let columns = primary_keys
.iter()
.map(|column| quote_ident(&column.name))
.collect::<Vec<_>>()
.join(", ");
definitions.push(format!("PRIMARY KEY ({columns})"));
}
let columns = definitions.join(",\n ");
format!(
"CREATE TABLE {} (\n {columns}\n);\n",
quote_ident(&table.name)
)
}
#[must_use]
pub fn column_definition(column: &ColumnSchema, inline_primary_key: bool) -> String {
let mut fragments = vec![
quote_ident(&column.name),
sql_type(&column.data_type).to_owned(),
];
if matches!(column.generated, Some(GeneratedValueIr::AutoIncrement)) {
fragments.push("GENERATED BY DEFAULT AS IDENTITY".to_owned());
}
if !column.nullable {
fragments.push("NOT NULL".to_owned());
}
if column.primary_key && inline_primary_key {
fragments.push("PRIMARY KEY".to_owned());
} else if column.unique {
fragments.push("UNIQUE".to_owned());
}
if let Some(default) = sql_default(column) {
fragments.push(format!("DEFAULT {default}"));
}
if let DatabaseType::Enum { values } = &column.data_type {
let choices = values
.iter()
.map(|value| quote_literal(value))
.collect::<Vec<_>>()
.join(", ");
fragments.push(format!(
"CHECK ({} IN ({choices}))",
quote_ident(&column.name)
));
}
fragments.join(" ")
}
const fn sql_type(data_type: &DatabaseType) -> &'static str {
match data_type {
DatabaseType::Uuid => "UUID",
DatabaseType::Text | DatabaseType::Enum { .. } => "TEXT",
DatabaseType::Integer => "INTEGER",
DatabaseType::Bigint => "BIGINT",
DatabaseType::Decimal => "NUMERIC",
DatabaseType::Boolean => "BOOLEAN",
DatabaseType::Date => "DATE",
DatabaseType::Datetime => "TIMESTAMPTZ",
DatabaseType::Json => "JSONB",
}
}
#[must_use]
pub fn sql_default(column: &ColumnSchema) -> Option<String> {
if matches!(column.generated, Some(GeneratedValueIr::Now)) {
return Some("CURRENT_TIMESTAMP".to_owned());
}
if matches!(column.generated, Some(GeneratedValueIr::Revision)) {
return Some("1".to_owned());
}
let value = column.default.as_ref()?;
Some(match column.data_type {
DatabaseType::Boolean
| DatabaseType::Integer
| DatabaseType::Bigint
| DatabaseType::Decimal => value.clone(),
_ => quote_literal(value),
})
}
#[must_use]
pub fn add_foreign_key(foreign_key: &ForeignKeySchema) -> String {
let action = match foreign_key.on_delete {
OnDeleteIr::Restrict => "RESTRICT".to_owned(),
OnDeleteIr::Cascade => "CASCADE".to_owned(),
OnDeleteIr::SetNull if foreign_key.source_columns.len() > 1 => {
let nullable_columns = foreign_key.source_columns[1..]
.iter()
.map(|column| quote_ident(column))
.collect::<Vec<_>>()
.join(", ");
format!("SET NULL ({nullable_columns})")
}
OnDeleteIr::SetNull => "SET NULL".to_owned(),
};
let source_columns = quote_columns(&foreign_key.source_columns);
let target_columns = quote_columns(&foreign_key.target_columns);
let constraint = format!(
"fk_{}_{}",
foreign_key.source_table,
foreign_key.source_columns.join("_")
);
format!(
"ALTER TABLE {} ADD CONSTRAINT {} FOREIGN KEY ({source_columns}) REFERENCES {} ({target_columns}) ON DELETE {action};\n",
quote_ident(&foreign_key.source_table),
quote_ident(&constraint),
quote_ident(&foreign_key.target_table),
)
}
#[must_use]
pub fn add_unique_constraint(constraint: &UniqueConstraintSchema) -> String {
let name = format!("uq_{}_{}", constraint.table, constraint.columns.join("_"));
let columns = quote_columns(&constraint.columns);
format!(
"ALTER TABLE {} ADD CONSTRAINT {} UNIQUE ({columns});\n",
quote_ident(&constraint.table),
quote_ident(&name)
)
}
#[must_use]
pub fn add_index(index: &IndexSchema) -> String {
let unique = if index.unique { " UNIQUE" } else { "" };
let predicate = index
.predicate
.as_ref()
.map_or_else(String::new, |value| format!(" WHERE ({value})"));
let extension = if index.operator_class == Some(appstruct_ir::IndexOperatorClass::GinTrgmOps) {
"CREATE EXTENSION IF NOT EXISTS pg_trgm;\n"
} else {
""
};
let method = if index.method == appstruct_ir::IndexMethod::Btree {
String::new()
} else {
format!(" USING {}", index.method.sql())
};
let columns = index
.columns
.iter()
.map(|column| {
let class = index
.operator_class
.map_or_else(String::new, |class| format!(" {}", class.sql()));
format!("{}{class}", quote_ident(column))
})
.collect::<Vec<_>>()
.join(", ");
format!(
"{extension}CREATE{unique} INDEX {} ON {}{method} ({columns}){predicate};\n",
quote_ident(&index_name(index)),
quote_ident(&index.table),
)
}
fn index_name(index: &IndexSchema) -> String {
let suffix = index.id.rsplit("::").next().unwrap_or(index.id.as_str());
format!("idx_{}", suffix.replace('.', "_"))
}
#[must_use]
pub fn add_seed(seed: &SeedSchema) -> String {
let columns = seed
.values
.iter()
.map(|value| quote_ident(&value.column))
.collect::<Vec<_>>()
.join(", ");
let values = seed
.values
.iter()
.map(|value| seed_value(&value.value, &value.data_type))
.collect::<Vec<_>>()
.join(", ");
format!(
"INSERT INTO {} ({columns}) VALUES ({values}) ON CONFLICT DO NOTHING;\n",
quote_ident(&seed.table)
)
}
fn seed_value(value: &str, data_type: &DatabaseType) -> String {
match data_type {
DatabaseType::Boolean if matches!(value, "true" | "false") => value.to_owned(),
DatabaseType::Integer if value.parse::<i32>().is_ok() => value.to_owned(),
DatabaseType::Bigint if value.parse::<i64>().is_ok() => value.to_owned(),
DatabaseType::Decimal if value.parse::<f64>().is_ok_and(f64::is_finite) => value.to_owned(),
_ => quote_literal(value),
}
}
fn quote_columns(columns: &[String]) -> String {
columns
.iter()
.map(|column| quote_ident(column))
.collect::<Vec<_>>()
.join(", ")
}
#[must_use]
pub fn generated_header() -> String {
"-- @generated by AppStruct. Review before applying.\n".to_owned()
}
#[must_use]
pub fn quote_ident(value: &str) -> String {
format!("\"{}\"", value.replace('"', "\"\""))
}
#[must_use]
pub fn quote_literal(value: &str) -> String {
format!("'{}'", value.replace('\'', "''"))
}