Foreign key relation results in erroneous second migration about prisma HOT 1 OPEN

pub(crate) fn foreign_key_pairs(&self) -> impl Iterator<Item = MigrationPair<ForeignKeyWalker<'schema>>> + '_ {
        self.previous_foreign_keys().filter_map(move |previous_fk| {
            self.next_foreign_keys()
                .find(move |next_fk| foreign_keys_match(MigrationPair::new(&previous_fk, next_fk), self.db))
                .map(move |next_fk| MigrationPair::new(previous_fk, next_fk))
        })
    }

    references_same_table
        && references_same_column_count
        && constrains_same_column_count
        && constrains_same_columns
        && references_same_columns
        && same_on_delete_action
        && same_on_update_action

    if fk
        .map(|fk| fk.constraint_name())
        .transpose()
        .map(|names| names.previous != names.next)
        .unwrap_or(false)
    {
        // Rename the foreign key.


        // Since we are using the conventional foreign key names for the foreign keys of
        // many-to-many relation tables, but we used not to (we did not provide a constraint
        // names), and we do not want to cause new migrations on upgrade, we ignore the foreign
        // keys of implicit many-to-many relation tables for renamings.
        if fk.map(is_prisma_implicit_m2m_fk).into_tuple() == (true, true) {
            return;
        }


        if db.flavour.can_rename_foreign_key() {
            steps.push(SqlMigrationStep::RenameForeignKey {
                foreign_key_id: fk.map(|fk| fk.id),
            })
        } else {
            steps.push(SqlMigrationStep::AddForeignKey {
                foreign_key_id: fk.next.id,
            });
            steps.push(SqlMigrationStep::DropForeignKey {
                foreign_key_id: fk.previous.id,
            })
        }
    }
}

    pub(crate) fn index_pairs<'a>(&'a self) -> impl Iterator<Item = MigrationPair<IndexWalker<'schema>>> + 'a {
        let singular_indexes = self.previous_indexes().filter(move |left| {
            // Renaming an index in a situation where we have multiple indexes
            // with the same columns, but a different name, is highly unstable.
            // We do not rename them for now.
            let number_of_identical_indexes = self
                .previous_indexes()
                .filter(|right| {
                    left.column_names().len() == right.column_names().len()
                        && left.column_names().zip(right.column_names()).all(|(a, b)| a == b)
                        && left.index_type() == right.index_type()
                })
                .count();


            number_of_identical_indexes == 1
        });


        singular_indexes.filter_map(move |previous_index| {
            self.next_indexes()
                .find(|next_index| indexes_match(previous_index, *next_index, self.db.flavour))
                .map(|renamed_index| MigrationPair::new(previous_index, renamed_index))
        })
    }