dinoco_engine/

planner.rs

use std::collections::{HashMap, HashSet};

use dinoco_compiler::{
    ParsedField, ParsedFieldDefault, ParsedFieldType, ParsedRelation, ParsedSchema, ParsedTable, ReferentialAction,
};

use crate::{MigrationPlan, MigrationStep, SafetyLevel, is_destructive_cast};

fn primary_key_type(table: &ParsedTable, field_name: &str) -> Option<ParsedFieldType> {
    table.fields.iter().find(|field| field.name == field_name).map(|field| field.field_type.clone())
}

fn primary_key_constraint_name(table_name: &str) -> Option<String> {
    Some(format!("pk_{}", table_name))
}

fn push_safety_alert(alerts: &mut Vec<SafetyLevel>, alert: SafetyLevel) {
    let exists = alerts.iter().any(|item| match (item, &alert) {
        (SafetyLevel::Warning(left), SafetyLevel::Warning(right)) => left == right,
        (SafetyLevel::Destructive(left), SafetyLevel::Destructive(right)) => left == right,
        _ => false,
    });

    if !exists {
        alerts.push(alert);
    }
}

fn diff_primary_key(
    old_table: &ParsedTable,
    new_table: &ParsedTable,
    alerts: &mut Vec<SafetyLevel>,
) -> Vec<MigrationStep> {
    if old_table.primary_key_fields == new_table.primary_key_fields {
        return Vec::new();
    }

    let old_primary_key = if old_table.primary_key_fields.is_empty() {
        "(none)".to_string()
    } else {
        old_table.primary_key_fields.join(", ")
    };
    let new_primary_key = if new_table.primary_key_fields.is_empty() {
        "(none)".to_string()
    } else {
        new_table.primary_key_fields.join(", ")
    };

    push_safety_alert(
        alerts,
        SafetyLevel::Destructive(format!(
            "Primary key changed on table '{}': [{}] -> [{}]. This can fail if existing data violates the new primary key or dependent relations still use the old key.",
            new_table.database_name, old_primary_key, new_primary_key
        )),
    );

    let mut steps = Vec::new();

    if !old_table.primary_key_fields.is_empty() {
        steps.push(MigrationStep::DropPrimaryKey {
            table_name: old_table.database_name.clone(),
            constraint_name: primary_key_constraint_name(&old_table.database_name),
        });
    }

    if !new_table.primary_key_fields.is_empty() {
        steps.push(MigrationStep::AddPrimaryKey {
            table_name: new_table.database_name.clone(),
            columns: new_table.primary_key_fields.clone(),
            constraint_name: primary_key_constraint_name(&new_table.database_name),
        });
    }

    steps
}

fn explicit_index_name(table_name: &str, columns: &[String], is_unique: bool) -> String {
    let suffix = columns.join("_");

    if is_unique { format!("uq_{}_{}", table_name, suffix) } else { format!("idx_{}_{}", table_name, suffix) }
}

fn diff_table_indexes(old_table: &ParsedTable, new_table: &ParsedTable) -> Vec<MigrationStep> {
    let old_unique = old_table.unique_field_sets.iter().map(|columns| (true, columns.clone())).collect::<Vec<_>>();
    let old_indexes = old_table.index_field_sets.iter().map(|columns| (false, columns.clone())).collect::<Vec<_>>();
    let new_unique = new_table.unique_field_sets.iter().map(|columns| (true, columns.clone())).collect::<Vec<_>>();
    let new_indexes = new_table.index_field_sets.iter().map(|columns| (false, columns.clone())).collect::<Vec<_>>();

    let old_all = old_unique.into_iter().chain(old_indexes).collect::<Vec<_>>();
    let new_all = new_unique.into_iter().chain(new_indexes).collect::<Vec<_>>();
    let old_signatures = old_all
        .iter()
        .map(|(is_unique, columns)| ((*is_unique, columns.join("|")), columns.clone()))
        .collect::<HashMap<_, _>>();
    let new_signatures = new_all
        .iter()
        .map(|(is_unique, columns)| ((*is_unique, columns.join("|")), columns.clone()))
        .collect::<HashMap<_, _>>();
    let mut steps = Vec::new();

    for ((is_unique, _), columns) in &old_signatures {
        if !new_signatures.contains_key(&(*is_unique, columns.join("|"))) {
            steps.push(MigrationStep::DropIndex {
                table_name: old_table.database_name.clone(),
                index_name: explicit_index_name(&old_table.database_name, columns, *is_unique),
            });
        }
    }

    for ((is_unique, _), columns) in &new_signatures {
        if !old_signatures.contains_key(&(*is_unique, columns.join("|"))) {
            steps.push(MigrationStep::CreateIndex {
                table_name: new_table.database_name.clone(),
                columns: columns.clone(),
                index_name: explicit_index_name(&new_table.database_name, columns, *is_unique),
                is_unique: *is_unique,
            });
        }
    }

    steps
}

pub fn calculate_diff(old_schema: &Option<ParsedSchema>, new_schema: &ParsedSchema) -> MigrationPlan {
    let fallback_old_schema = ParsedSchema { config: new_schema.config.clone(), enums: Vec::new(), tables: Vec::new() };
    let old_schema = old_schema.as_ref().unwrap_or(&fallback_old_schema);

    let mut safety_alerts = Vec::new();

    let mut create_enum_steps = Vec::new();
    let mut alter_enum_steps = Vec::new();
    let mut drop_enum_steps = Vec::new();
    let mut drop_fk_steps = Vec::new();
    let mut drop_index_steps = Vec::new();
    let mut drop_table_steps = Vec::new();
    let mut create_table_steps = Vec::new();
    let mut add_column_steps = Vec::new();
    let mut drop_column_steps = Vec::new();
    let mut alter_column_steps = Vec::new();
    let mut primary_key_steps = Vec::new();
    let mut create_index_steps = Vec::new();
    let mut add_fk_steps = Vec::new();
    let mut created_table_names = HashSet::new();

    let old_enums_map: HashMap<&String, _> = old_schema.enums.iter().map(|e| (&e.name, e)).collect();
    let new_enums_map: HashMap<&String, _> = new_schema.enums.iter().map(|e| (&e.name, e)).collect();

    for (name, new_enum) in &new_enums_map {
        if let Some(old_enum) = old_enums_map.get(name) {
            if old_enum.values != new_enum.values {
                alter_enum_steps.push(MigrationStep::AlterEnum {
                    name: (*name).clone(),
                    old_variants: old_enum.values.clone(),
                    new_variants: new_enum.values.clone(),
                });
            }
        } else {
            create_enum_steps
                .push(MigrationStep::CreateEnum { name: (*name).clone(), variants: new_enum.values.clone() });
        }
    }

    for name in old_enums_map.keys() {
        if !new_enums_map.contains_key(name) {
            drop_enum_steps.push(MigrationStep::DropEnum((*name).clone()));
        }
    }

    let old_map: HashMap<&String, &ParsedTable> = old_schema.tables.iter().map(|t| (&t.name, t)).collect();
    let new_map: HashMap<&String, &ParsedTable> = new_schema.tables.iter().map(|t| (&t.name, t)).collect();

    let mut old_join_tables = HashMap::new();
    for table in &old_schema.tables {
        let (_, jts) = extract_relations(None, table, &old_schema.tables);
        for jt in jts {
            old_join_tables.insert(jt.name.clone(), jt);
        }
    }

    let mut new_join_tables_map = HashMap::new();

    for (name, new_table) in &new_map {
        if let Some(old_table) = old_map.get(name) {
            if old_table.database_name != new_table.database_name {
                push_safety_alert(
                    &mut safety_alerts,
                    SafetyLevel::Warning(format!(
                        "Table '{}' will be renamed to '{}'. Existing queries or raw SQL using the old physical table name may need updates.",
                        old_table.database_name, new_table.database_name
                    )),
                );
                created_table_names.insert(new_table.database_name.clone());
                create_table_steps.push(MigrationStep::RenameTable {
                    old_name: old_table.database_name.clone(),
                    new_name: new_table.database_name.clone(),
                });
            }

            primary_key_steps.extend(diff_primary_key(old_table, new_table, &mut safety_alerts));
            for step in diff_table_indexes(old_table, new_table) {
                match step {
                    MigrationStep::DropIndex { .. } => drop_index_steps.push(step),
                    MigrationStep::CreateIndex { .. } => create_index_steps.push(step),
                    _ => {}
                }
            }

            for step in diff_columns(old_table, new_table, &mut safety_alerts) {
                match step {
                    MigrationStep::AddColumn { .. } => add_column_steps.push(step),
                    MigrationStep::DropColumn { .. } => drop_column_steps.push(step),
                    MigrationStep::DropForeignKey { .. } => drop_fk_steps.push(step),
                    MigrationStep::AlterColumn { .. } | MigrationStep::RenameColumn { .. } => {
                        alter_column_steps.push(step)
                    }
                    _ => {}
                }
            }
        } else {
            create_table_steps.push(MigrationStep::CreateTable((*new_table).clone()));
            created_table_names.insert(new_table.database_name.clone());
        }

        let (relations_steps, join_tables) =
            extract_relations(old_map.get(name).copied(), new_table, &new_schema.tables);

        for step in relations_steps {
            match step {
                MigrationStep::AddForeignKey { ref table_name, .. } => {
                    if !created_table_names.contains(table_name) {
                        add_fk_steps.push(step);
                    }
                }
                MigrationStep::DropForeignKey { .. } => drop_fk_steps.push(step),
                MigrationStep::CreateIndex { .. } => create_index_steps.push(step),
                _ => {}
            }
        }

        for join_table in join_tables {
            new_join_tables_map.insert(join_table.name.clone(), join_table.clone());

            if !old_map.contains_key(&join_table.name) && !old_join_tables.contains_key(&join_table.name) {
                created_table_names.insert(join_table.database_name.clone());
                create_table_steps.push(MigrationStep::CreateTable(join_table));
            }
        }
    }

    for (name, old_table) in &old_map {
        if !new_map.contains_key(*name) {
            for field in &old_table.fields {
                if let ParsedRelation::ManyToOne(_, local_cols, _, _, _)
                | ParsedRelation::OneToOneOwner(_, local_cols, _, _, _) = &field.relation
                {
                    if !local_cols.is_empty() {
                        drop_fk_steps.push(MigrationStep::DropForeignKey {
                            table_name: old_table.database_name.clone(),
                            constraint_name: format!("fk_{}_{}", old_table.database_name, local_cols.join("_")),
                        });
                    }
                }
            }
        }
    }

    for name in old_join_tables.keys() {
        if !new_join_tables_map.contains_key(name) {
            drop_table_steps.push(MigrationStep::DropTable(name.clone()));
        }
    }

    for (name, old_table) in &old_map {
        if !new_map.contains_key(name) {
            safety_alerts.push(SafetyLevel::Destructive(format!(
                "Dropping table '{}'. All records will be permanently deleted.",
                old_table.database_name
            )));

            drop_table_steps.push(MigrationStep::DropTable(old_table.database_name.clone()));
        }
    }

    let mut final_steps = Vec::new();

    final_steps.extend(create_enum_steps);
    final_steps.extend(drop_fk_steps);
    final_steps.extend(drop_index_steps);
    final_steps.extend(drop_table_steps);
    final_steps.extend(alter_enum_steps);
    final_steps.extend(create_table_steps);
    final_steps.extend(drop_column_steps);
    final_steps.extend(add_column_steps);
    final_steps.extend(alter_column_steps);
    final_steps.extend(primary_key_steps);
    final_steps.extend(create_index_steps);
    final_steps.extend(add_fk_steps);
    final_steps.extend(drop_enum_steps);

    MigrationPlan { steps: final_steps, safety_alerts }
}
fn diff_columns(old_table: &ParsedTable, new_table: &ParsedTable, alerts: &mut Vec<SafetyLevel>) -> Vec<MigrationStep> {
    let mut steps = Vec::new();

    let old_fields: HashMap<&String, &ParsedField> =
        old_table.fields.iter().filter(|f| !f.is_virtual).map(|f| (&f.name, f)).collect();
    let new_fields: HashMap<&String, &ParsedField> =
        new_table.fields.iter().filter(|f| !f.is_virtual).map(|f| (&f.name, f)).collect();

    let mut added_fields = Vec::new();
    let mut dropped_fields = Vec::new();

    for (name, new_field) in &new_fields {
        if matches!(new_field.field_type, ParsedFieldType::Relation(..)) {
            continue;
        }

        if let Some(old_field) = old_fields.get(name) {
            let type_changed = old_field.field_type != new_field.field_type;
            let became_required = old_field.is_optional && !new_field.is_optional;
            let default_value = old_field.default_value != new_field.default_value;
            let unique = old_field.is_unique != new_field.is_unique;

            if type_changed || became_required || default_value || unique {
                if type_changed && is_destructive_cast(&old_field.field_type, &new_field.field_type) {
                    push_safety_alert(
                        alerts,
                        SafetyLevel::Destructive(format!(
                            "Incompatible type change in '{}.{}': {:?} -> {:?}. Existing values may not be convertible.",
                            new_table.database_name, name, old_field.field_type, new_field.field_type
                        )),
                    );
                }

                if became_required && new_field.default_value == ParsedFieldDefault::NotDefined {
                    push_safety_alert(
                        alerts,
                        SafetyLevel::Warning(format!(
                            "Column '{}.{}' was changed from optional to required without a default value. This migration can fail if existing rows contain NULL.",
                            new_table.database_name, name
                        )),
                    );
                }

                steps.push(MigrationStep::AlterColumn {
                    table_name: new_table.database_name.clone(),
                    old_field: (*old_field).clone(),
                    new_field: (*new_field).clone(),
                });
            }
        } else {
            added_fields.push(*new_field);
        }
    }

    for (name, old_field) in &old_fields {
        if matches!(old_field.field_type, ParsedFieldType::Relation(..)) {
            continue;
        }

        if !new_fields.contains_key(name) {
            dropped_fields.push(*old_field);
        }
    }

    let mut resolved_adds = HashSet::new();
    let mut resolved_drops = HashSet::new();

    for add_f in added_fields.iter() {
        if let Some(drop_f) = dropped_fields.iter().find(|d| {
            !resolved_drops.contains(&d.name)
                && d.field_type == add_f.field_type
                && d.is_optional == add_f.is_optional
                && d.default_value == add_f.default_value
                && d.relation == add_f.relation
        }) {
            steps.push(MigrationStep::RenameColumn {
                table_name: new_table.database_name.clone(),
                old_name: drop_f.name.clone(),
                new_name: add_f.name.clone(),
            });

            if let ParsedRelation::ManyToOne(_, local_cols, _, _, _)
            | ParsedRelation::OneToOneOwner(_, local_cols, _, _, _) = &drop_f.relation
            {
                if !local_cols.is_empty() {
                    steps.push(MigrationStep::DropForeignKey {
                        table_name: old_table.database_name.clone(),
                        constraint_name: format!("fk_{}_{}", old_table.database_name, local_cols.join("_")),
                    });
                }
            }

            resolved_adds.insert(add_f.name.clone());
            resolved_drops.insert(drop_f.name.clone());
        }
    }

    for add_f in added_fields {
        if !resolved_adds.contains(&add_f.name) {
            if !add_f.is_optional
                && add_f.default_value == ParsedFieldDefault::NotDefined
                && old_table
                    .fields
                    .iter()
                    .any(|field| !field.is_virtual && !matches!(field.field_type, ParsedFieldType::Relation(..)))
            {
                push_safety_alert(
                    alerts,
                    SafetyLevel::Warning(format!(
                        "Adding required column '{}.{}' without a default value can fail on tables that already contain rows.",
                        new_table.database_name, add_f.name
                    )),
                );
            }

            steps.push(MigrationStep::AddColumn { table_name: new_table.database_name.clone(), field: add_f.clone() });
        }
    }

    for drop_f in dropped_fields {
        if !resolved_drops.contains(&drop_f.name) {
            if let ParsedRelation::ManyToOne(_, local_cols, _, _, _)
            | ParsedRelation::OneToOneOwner(_, local_cols, _, _, _) = &drop_f.relation
            {
                if !local_cols.is_empty() {
                    steps.push(MigrationStep::DropForeignKey {
                        table_name: old_table.database_name.clone(),
                        constraint_name: format!("fk_{}_{}", old_table.database_name, local_cols.join("_")),
                    });
                }
            }

            push_safety_alert(
                alerts,
                SafetyLevel::Destructive(format!(
                    "Dropping column '{}.{}'. All data stored in this column will be permanently lost.",
                    old_table.database_name, drop_f.name
                )),
            );

            steps
                .push(MigrationStep::DropColumn { table_name: old_table.database_name.clone(), field: drop_f.clone() });
        }
    }

    steps
}

pub fn extract_relations(
    old_table: Option<&ParsedTable>,
    new_table: &ParsedTable,
    all_tables: &[ParsedTable],
) -> (Vec<MigrationStep>, Vec<ParsedTable>) {
    let mut fk_steps = Vec::new();
    let mut join_tables = Vec::new();
    let tables_by_name: HashMap<&str, &ParsedTable> =
        all_tables.iter().map(|table| (table.name.as_str(), table)).collect();

    let mut processed_m2m = HashSet::new();

    for field in &new_table.fields {
        let is_unchanged = if let Some(old_t) = old_table {
            if let Some(old_f) = old_t.fields.iter().find(|f| f.name == field.name) {
                old_f.relation == field.relation && old_f.field_type == field.field_type
            } else {
                false
            }
        } else {
            false
        };

        match &field.relation {
            ParsedRelation::ManyToOne(_, local_cols, ref_cols, on_delete, on_update)
            | ParsedRelation::OneToOneOwner(_, local_cols, ref_cols, on_delete, on_update) => {
                if is_unchanged {
                    continue;
                }

                if !local_cols.is_empty() && local_cols.len() == ref_cols.len() {
                    let ref_table = match &field.field_type {
                        ParsedFieldType::Relation(name) => name.clone(),
                        _ => field.field_type.to_string(),
                    };

                    fk_steps.push(MigrationStep::AddForeignKey {
                        table_name: new_table.database_name.clone(),
                        columns: local_cols.clone(),
                        referenced_table: tables_by_name
                            .get(ref_table.as_str())
                            .map(|table| table.database_name.clone())
                            .unwrap_or(ref_table),
                        referenced_columns: ref_cols.clone(),
                        on_delete: on_delete.clone(),
                        on_update: on_update.clone(),
                        constraint_name: format!("fk_{}_{}", new_table.database_name, local_cols.join("_")),
                    });
                }
            }
            ParsedRelation::ManyToMany(relation_name) => {
                let target_table_name = match &field.field_type {
                    ParsedFieldType::Relation(name) => name.clone(),
                    _ => continue,
                };

                if new_table.name <= target_table_name {
                    let Some(safe_rel_name) = build_many_to_many_join_table_name(
                        new_table,
                        field,
                        &target_table_name,
                        relation_name.as_deref(),
                        all_tables,
                    ) else {
                        continue;
                    };

                    if !processed_m2m.insert(safe_rel_name.clone()) {
                        continue;
                    }

                    let t1_clean = new_table.database_name.replace("\"", "").to_lowercase();
                    let t2_clean = tables_by_name
                        .get(target_table_name.as_str())
                        .map(|table| table.database_name.replace("\"", "").to_lowercase())
                        .unwrap_or_else(|| target_table_name.replace("\"", "").to_lowercase());

                    let target_table = tables_by_name.get(target_table_name.as_str()).copied();
                    let current_primary_keys = new_table.primary_key_fields.clone();
                    let target_primary_keys =
                        target_table.map(|table| table.primary_key_fields.clone()).unwrap_or_default();

                    let self_relation = new_table.name == target_table_name;
                    let current_join_columns = current_primary_keys
                        .iter()
                        .map(|field_name| {
                            if self_relation {
                                format!("{}_A_{}", t1_clean, field_name)
                            } else {
                                format!("{}_{}", t1_clean, field_name)
                            }
                        })
                        .collect::<Vec<_>>();
                    let target_join_columns = target_primary_keys
                        .iter()
                        .map(|field_name| {
                            if self_relation {
                                format!("{}_B_{}", t1_clean, field_name)
                            } else {
                                format!("{}_{}", t2_clean, field_name)
                            }
                        })
                        .collect::<Vec<_>>();

                    let mut join_fields = Vec::new();
                    for (column_name, field_name) in current_join_columns.iter().zip(current_primary_keys.iter()) {
                        join_fields.push(ParsedField {
                            name: column_name.clone(),
                            field_type: primary_key_type(new_table, field_name).unwrap_or(ParsedFieldType::Integer),
                            is_primary_key: false,
                            is_optional: false,
                            is_unique: false,
                            is_virtual: false,
                            is_list: false,
                            relation: ParsedRelation::NotDefined,
                            default_value: ParsedFieldDefault::NotDefined,
                        });
                    }

                    if let Some(target_table) = target_table {
                        for (column_name, field_name) in target_join_columns.iter().zip(target_primary_keys.iter()) {
                            join_fields.push(ParsedField {
                                name: column_name.clone(),
                                field_type: primary_key_type(target_table, field_name)
                                    .unwrap_or(ParsedFieldType::Integer),
                                is_primary_key: false,
                                is_optional: false,
                                is_unique: false,
                                is_virtual: false,
                                is_list: false,
                                relation: ParsedRelation::NotDefined,
                                default_value: ParsedFieldDefault::NotDefined,
                            });
                        }
                    }

                    let join_table = ParsedTable {
                        name: safe_rel_name.clone(),
                        database_name: safe_rel_name.clone(),
                        primary_key_fields: current_join_columns
                            .iter()
                            .chain(target_join_columns.iter())
                            .cloned()
                            .collect(),
                        unique_field_sets: Vec::new(),
                        index_field_sets: Vec::new(),
                        fields: join_fields,
                    };

                    join_tables.push(join_table.clone());

                    if is_unchanged {
                        continue;
                    }

                    fk_steps.push(MigrationStep::AddForeignKey {
                        table_name: safe_rel_name.clone(),
                        columns: current_join_columns.clone(),
                        referenced_table: new_table.database_name.clone(),
                        referenced_columns: new_table.primary_key_fields.clone(),
                        on_delete: Some(ReferentialAction::Cascade),
                        on_update: Some(ReferentialAction::Cascade),
                        constraint_name: format!("fk_{}_{}", safe_rel_name, current_join_columns.join("_")),
                    });

                    fk_steps.push(MigrationStep::AddForeignKey {
                        table_name: safe_rel_name.clone(),
                        columns: target_join_columns.clone(),
                        referenced_table: tables_by_name
                            .get(target_table_name.as_str())
                            .map(|table| table.database_name.clone())
                            .unwrap_or(target_table_name.clone()),
                        referenced_columns: tables_by_name
                            .get(target_table_name.as_str())
                            .map(|table| table.primary_key_fields.clone())
                            .unwrap_or_else(|| vec!["id".to_string()]),
                        on_delete: Some(ReferentialAction::Cascade),
                        on_update: Some(ReferentialAction::Cascade),
                        constraint_name: format!("fk_{}_{}", safe_rel_name, target_join_columns.join("_")),
                    });

                    let index_name =
                        format!("{}_{}_idx", safe_rel_name.replace("\"", ""), target_join_columns.join("_"));

                    fk_steps.push(MigrationStep::CreateIndex {
                        table_name: safe_rel_name.clone(),
                        columns: target_join_columns,
                        index_name,
                        is_unique: false,
                    });
                }
            }
            _ => {}
        }
    }

    (fk_steps, join_tables)
}

fn build_many_to_many_join_table_name(
    current_table: &ParsedTable,
    current_field: &ParsedField,
    target_table_name: &str,
    relation_name: Option<&str>,
    all_tables: &[ParsedTable],
) -> Option<String> {
    if let Some(relation_name) = relation_name {
        return Some(format!("_{}", relation_name.replace('"', "")));
    }

    if current_table.name == target_table_name {
        let anchor_field =
            find_many_to_many_counterpart(current_table, current_field, target_table_name, relation_name, all_tables)
                .map(|field| if current_field.name <= field.name { current_field } else { field })
                .unwrap_or(current_field);

        return Some(format!("_{}{}", current_table.name, pascal_case(&anchor_field.name)));
    }

    if current_table.name.as_str() < target_table_name {
        return Some(format!("_{}{}", current_table.name, pascal_case(&current_field.name)));
    }

    let counterpart =
        find_many_to_many_counterpart(current_table, current_field, target_table_name, relation_name, all_tables)?;

    Some(format!("_{}{}", target_table_name, pascal_case(&counterpart.name)))
}

fn find_many_to_many_counterpart<'a>(
    current_table: &ParsedTable,
    current_field: &ParsedField,
    target_table_name: &str,
    relation_name: Option<&str>,
    all_tables: &'a [ParsedTable],
) -> Option<&'a ParsedField> {
    let target_table = all_tables.iter().find(|table| table.name == target_table_name)?;

    target_table.fields.iter().find(|candidate| {
        if !matches!(candidate.field_type, ParsedFieldType::Relation(ref target) if target == &current_table.name) {
            return false;
        }

        if current_table.name == target_table_name && candidate.name == current_field.name {
            return false;
        }

        matches!(
            &candidate.relation,
            ParsedRelation::ManyToMany(candidate_relation_name)
                if candidate_relation_name.as_deref() == relation_name
        )
    })
}

fn pascal_case(value: &str) -> String {
    let mut output = String::new();
    let mut uppercase_next = true;

    for ch in value.chars() {
        if ch == '_' || ch == '-' || ch == ' ' {
            uppercase_next = true;
            continue;
        }

        if uppercase_next {
            output.extend(ch.to_uppercase());
            uppercase_next = false;
        } else {
            output.push(ch);
        }
    }

    output
}