appstruct-migrate 0.1.0

PostgreSQL schema diffing and migration execution for AppStruct
Documentation
use crate::{
    ColumnSchema, DatabaseSchema, DatabaseType, ForeignKeySchema, IndexSchema, MigrationPlan,
    SchemaChange, 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"))
}

/// Render SQL for an automatically applicable migration plan.
///
/// # Errors
///
/// Returns an error when the plan contains a blocked or unsupported change.
pub fn migration_sql(plan: &MigrationPlan) -> Result<String, String> {
    if plan.is_blocked() {
        return Err("migration contains changes that require review or input".to_owned());
    }
    let mut statements = vec![generated_header()];
    for planned in &plan.changes {
        statements.push(match &planned.change {
            SchemaChange::AddTable { table } => create_table(table),
            SchemaChange::AddColumn { table, column } => format!(
                "ALTER TABLE {} ADD COLUMN {};\n",
                quote_ident(table),
                column_definition(column, true)
            ),
            SchemaChange::AlterColumn {
                table,
                before,
                after,
            } => alter_column(table, before, after)?,
            SchemaChange::AddUniqueConstraint { constraint } => add_unique_constraint(constraint),
            SchemaChange::AddIndex { index } => add_index(index),
            SchemaChange::AddSeed { seed } => add_seed(seed),
            SchemaChange::AddForeignKey { foreign_key } => add_foreign_key(foreign_key),
            SchemaChange::RemoveTable { .. }
            | SchemaChange::RenameTable { .. }
            | SchemaChange::RemoveColumn { .. }
            | SchemaChange::RemoveUniqueConstraint { .. }
            | SchemaChange::RemoveIndex { .. }
            | SchemaChange::RemoveSeed { .. }
            | SchemaChange::RemoveForeignKey { .. } => {
                return Err("destructive migration cannot be rendered automatically".to_owned());
            }
        });
    }
    Ok(format!("{}\n", statements.join("\n")))
}

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)
    )
}

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",
    }
}

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),
    })
}

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),
    )
}

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)
    )
}

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})"));
    format!(
        "CREATE{unique} INDEX {} ON {} ({}){predicate};\n",
        quote_ident(&index_name(index)),
        quote_ident(&index.table),
        quote_columns(&index.columns),
    )
}

fn index_name(index: &IndexSchema) -> String {
    let suffix = index.id.rsplit("::").next().unwrap_or(index.id.as_str());
    format!("idx_{}", suffix.replace('.', "_"))
}

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(", ")
}

fn alter_column(
    table: &str,
    before: &ColumnSchema,
    after: &ColumnSchema,
) -> Result<String, String> {
    if before.name != after.name
        || before.data_type != after.data_type
        || before.primary_key != after.primary_key
        || before.unique != after.unique
        || before.generated != after.generated
    {
        return Err("column shape change requires manual migration".to_owned());
    }
    if before.nullable && !after.nullable {
        return Err("adding a not-null constraint requires manual migration".to_owned());
    }
    let prefix = format!(
        "ALTER TABLE {} ALTER COLUMN {}",
        quote_ident(table),
        quote_ident(&after.name)
    );
    let mut statements = Vec::new();
    if before.nullable != after.nullable {
        statements.push(format!("{prefix} DROP NOT NULL;\n"));
    }
    if before.default != after.default {
        statements.push(sql_default(after).map_or_else(
            || format!("{prefix} DROP DEFAULT;\n"),
            |default| format!("{prefix} SET DEFAULT {default};\n"),
        ));
    }
    Ok(statements.concat())
}

fn generated_header() -> String {
    "-- @generated by AppStruct. Review before applying.\n".to_owned()
}

fn quote_ident(value: &str) -> String {
    format!("\"{}\"", value.replace('"', "\"\""))
}

fn quote_literal(value: &str) -> String {
    format!("'{}'", value.replace('\'', "''"))
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn quotes_sql_values() {
        assert_eq!(quote_ident("project\"name"), "\"project\"\"name\"");
        assert_eq!(quote_literal("it's"), "'it''s'");
    }
}