appstruct-migrate 0.2.0

PostgreSQL schema diffing and migration execution for AppStruct
Documentation
mod indexes;
mod seeds;
use self::indexes::diff_indexes;
use self::seeds::diff_seeds;
use crate::{
    ColumnSchema, DatabaseSchema, ForeignKeySchema, IndexSchema, TableSchema,
    UniqueConstraintSchema,
};
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;

#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum SchemaRisk {
    NonDestructive,
    RequiresInput,
    Destructive,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "snake_case")]
pub enum ExecutionRisk {
    Online,
    MayLock,
    ManualReview,
}

#[derive(Clone, Copy, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct ChangeRisk {
    pub schema: SchemaRisk,
    pub execution: ExecutionRisk,
}

#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "kind", rename_all = "snake_case")]
pub enum SchemaChange {
    AddTable {
        table: TableSchema,
    },
    RemoveTable {
        table: TableSchema,
    },
    RenameTable {
        before: TableSchema,
        after: TableSchema,
    },
    AddColumn {
        table: String,
        column: ColumnSchema,
    },
    RemoveColumn {
        table: String,
        column: ColumnSchema,
    },
    AlterColumn {
        table: String,
        before: ColumnSchema,
        after: ColumnSchema,
    },
    AddUniqueConstraint {
        constraint: UniqueConstraintSchema,
    },
    RemoveUniqueConstraint {
        constraint: UniqueConstraintSchema,
    },
    AddIndex {
        index: IndexSchema,
    },
    RemoveIndex {
        index: IndexSchema,
    },
    AddSeed {
        seed: crate::SeedSchema,
    },
    RemoveSeed {
        seed: crate::SeedSchema,
    },
    AddForeignKey {
        foreign_key: ForeignKeySchema,
    },
    RemoveForeignKey {
        foreign_key: ForeignKeySchema,
    },
}

#[derive(Clone, Debug, PartialEq, Eq, Serialize, Deserialize)]
pub struct PlannedChange {
    pub change: SchemaChange,
    pub risk: ChangeRisk,
}

#[derive(Clone, Debug, Default, PartialEq, Eq, Serialize, Deserialize)]
pub struct MigrationPlan {
    pub changes: Vec<PlannedChange>,
}

impl MigrationPlan {
    #[must_use]
    pub fn is_empty(&self) -> bool {
        self.changes.is_empty()
    }

    #[must_use]
    pub fn is_blocked(&self) -> bool {
        self.changes.iter().any(|change| {
            change.risk.schema != SchemaRisk::NonDestructive
                || change.risk.execution != ExecutionRisk::Online
        })
    }
}

#[must_use]
pub fn diff(before: &DatabaseSchema, after: &DatabaseSchema) -> MigrationPlan {
    let mut changes = Vec::new();
    let old_tables = by_id(&before.tables, |table| table.id.as_str());
    let new_tables = by_id(&after.tables, |table| table.id.as_str());
    for table in &after.tables {
        match old_tables.get(table.id.as_str()) {
            None => changes.push(planned(
                SchemaChange::AddTable {
                    table: table.clone(),
                },
                safe(),
            )),
            Some(previous) => {
                if previous.name != table.name {
                    changes.push(planned(
                        SchemaChange::RenameTable {
                            before: (*previous).clone(),
                            after: table.clone(),
                        },
                        requires_input(),
                    ));
                }
                diff_columns(previous, table, &mut changes);
            }
        }
    }
    for table in &before.tables {
        if !new_tables.contains_key(table.id.as_str()) {
            changes.push(planned(
                SchemaChange::RemoveTable {
                    table: table.clone(),
                },
                destructive(),
            ));
        }
    }
    diff_unique_constraints(before, after, &old_tables, &mut changes);
    diff_indexes(before, after, &old_tables, &mut changes);
    diff_seeds(before, after, &mut changes);
    diff_foreign_keys(before, after, &old_tables, &mut changes);
    MigrationPlan { changes }
}

fn diff_unique_constraints(
    before: &DatabaseSchema,
    after: &DatabaseSchema,
    old_tables: &BTreeMap<&str, &TableSchema>,
    changes: &mut Vec<PlannedChange>,
) {
    let old = by_id(&before.unique_constraints, |constraint| {
        constraint.id.as_str()
    });
    let new = by_id(&after.unique_constraints, |constraint| {
        constraint.id.as_str()
    });
    for constraint in &after.unique_constraints {
        match old.get(constraint.id.as_str()) {
            None => changes.push(planned(
                SchemaChange::AddUniqueConstraint {
                    constraint: constraint.clone(),
                },
                if after.tables.iter().any(|table| {
                    table.name == constraint.table && !old_tables.contains_key(table.id.as_str())
                }) {
                    safe()
                } else {
                    may_lock()
                },
            )),
            Some(previous) if *previous != constraint => {
                changes.push(planned(
                    SchemaChange::RemoveUniqueConstraint {
                        constraint: (*previous).clone(),
                    },
                    destructive(),
                ));
                changes.push(planned(
                    SchemaChange::AddUniqueConstraint {
                        constraint: constraint.clone(),
                    },
                    may_lock(),
                ));
            }
            Some(_) => {}
        }
    }
    for constraint in &before.unique_constraints {
        if !new.contains_key(constraint.id.as_str()) {
            changes.push(planned(
                SchemaChange::RemoveUniqueConstraint {
                    constraint: constraint.clone(),
                },
                destructive(),
            ));
        }
    }
}

fn diff_columns(before: &TableSchema, after: &TableSchema, changes: &mut Vec<PlannedChange>) {
    let old_columns = by_id(&before.columns, |column| column.id.as_str());
    let new_columns = by_id(&after.columns, |column| column.id.as_str());
    for column in &after.columns {
        match old_columns.get(column.id.as_str()) {
            None => changes.push(planned(
                SchemaChange::AddColumn {
                    table: after.name.clone(),
                    column: column.clone(),
                },
                added_column_risk(column),
            )),
            Some(previous) if *previous != column => changes.push(planned(
                SchemaChange::AlterColumn {
                    table: after.name.clone(),
                    before: (*previous).clone(),
                    after: column.clone(),
                },
                altered_column_risk(previous, column),
            )),
            Some(_) => {}
        }
    }
    for column in &before.columns {
        if !new_columns.contains_key(column.id.as_str()) {
            changes.push(planned(
                SchemaChange::RemoveColumn {
                    table: before.name.clone(),
                    column: column.clone(),
                },
                destructive(),
            ));
        }
    }
}

fn diff_foreign_keys(
    before: &DatabaseSchema,
    after: &DatabaseSchema,
    old_tables: &BTreeMap<&str, &TableSchema>,
    changes: &mut Vec<PlannedChange>,
) {
    let old = by_id(&before.foreign_keys, |foreign_key| foreign_key.id.as_str());
    let new = by_id(&after.foreign_keys, |foreign_key| foreign_key.id.as_str());
    for foreign_key in &after.foreign_keys {
        match old.get(foreign_key.id.as_str()) {
            None => changes.push(planned(
                SchemaChange::AddForeignKey {
                    foreign_key: foreign_key.clone(),
                },
                if after.tables.iter().any(|table| {
                    table.name == foreign_key.source_table
                        && !old_tables.contains_key(table.id.as_str())
                }) {
                    safe()
                } else {
                    may_lock()
                },
            )),
            Some(previous) if *previous != foreign_key => {
                changes.push(planned(
                    SchemaChange::RemoveForeignKey {
                        foreign_key: (*previous).clone(),
                    },
                    destructive(),
                ));
                changes.push(planned(
                    SchemaChange::AddForeignKey {
                        foreign_key: foreign_key.clone(),
                    },
                    safe(),
                ));
            }
            Some(_) => {}
        }
    }
    for foreign_key in &before.foreign_keys {
        if !new.contains_key(foreign_key.id.as_str()) {
            changes.push(planned(
                SchemaChange::RemoveForeignKey {
                    foreign_key: foreign_key.clone(),
                },
                destructive(),
            ));
        }
    }
}

fn added_column_risk(column: &ColumnSchema) -> ChangeRisk {
    if column.unique {
        return ChangeRisk {
            schema: SchemaRisk::NonDestructive,
            execution: ExecutionRisk::ManualReview,
        };
    }
    if column.nullable {
        safe()
    } else {
        ChangeRisk {
            schema: SchemaRisk::RequiresInput,
            execution: ExecutionRisk::MayLock,
        }
    }
}

fn altered_column_risk(before: &ColumnSchema, after: &ColumnSchema) -> ChangeRisk {
    if before.name != after.name || before.nullable && !after.nullable {
        return requires_input();
    }
    if before.data_type != after.data_type
        || before.primary_key != after.primary_key
        || before.unique != after.unique
    {
        return destructive();
    }
    if before.generated != after.generated {
        return ChangeRisk {
            schema: SchemaRisk::RequiresInput,
            execution: ExecutionRisk::ManualReview,
        };
    }
    safe()
}

pub(super) fn by_id<T, F>(items: &[T], id: F) -> BTreeMap<&str, &T>
where
    F: Fn(&T) -> &str,
{
    items.iter().map(|item| (id(item), item)).collect()
}

pub(super) fn planned(change: SchemaChange, risk: ChangeRisk) -> PlannedChange {
    PlannedChange { change, risk }
}

pub(super) const fn safe() -> ChangeRisk {
    ChangeRisk {
        schema: SchemaRisk::NonDestructive,
        execution: ExecutionRisk::Online,
    }
}

pub(super) const fn may_lock() -> ChangeRisk {
    ChangeRisk {
        schema: SchemaRisk::NonDestructive,
        execution: ExecutionRisk::MayLock,
    }
}

pub(super) const fn requires_input() -> ChangeRisk {
    ChangeRisk {
        schema: SchemaRisk::RequiresInput,
        execution: ExecutionRisk::MayLock,
    }
}

pub(super) const fn destructive() -> ChangeRisk {
    ChangeRisk {
        schema: SchemaRisk::Destructive,
        execution: ExecutionRisk::ManualReview,
    }
}