fixed foreign key migration sorting issue

toramanlis · toramanlis · commit dc995267bf58 · 2025-03-31T02:49:46.000Z
diff --git a/src/Blueprint/BlueprintDiff.php b/src/Blueprint/BlueprintDiff.php
@@ -2,12 +2,13 @@
 
 namespace Toramanlis\ImplicitMigrations\Blueprint;
 
+use Exception;
 use Illuminate\Database\Schema\ColumnDefinition;
 use Illuminate\Support\Facades\App;
 use Illuminate\Support\Fluent;
 use Toramanlis\ImplicitMigrations\Attributes\IndexType;
 
-class BlueprintDiff
+class BlueprintDiff implements Migratable
 {
     /**
      * @param SimplifyingBlueprint $from
@@ -29,11 +30,9 @@ public function __construct(
         public array $renamedIndexes,
         public array $addedIndexes
     ) {
-        $this->applyColumnIndexes();
-        $this->applyColumnIndexes(true);
     }
 
-    protected function applyColumnIndexes(bool $reverse = false)
+    public function applyColumnIndexes(bool $reverse = false)
     {
         /** @var SimplifyingBlueprint */
         $blueprint = App::make(SimplifyingBlueprint::class, ['tableName' => $this->to->getTable()]);
@@ -162,4 +161,45 @@ public function getRename(bool $reverse = false)
         $rename = [$this->from->getTable(), $this->to->getTable()];
         return $reverse ? array_reverse($rename) : $rename;
     }
+
+    public function getDependedColumnNames(): array
+    {
+        $dependedColumns = [];
+        foreach ($this->addedIndexes as $index) {
+            if (IndexType::Foreign->value !== $index->name) {
+                continue;
+            }
+
+            $references = is_array($index->references) ? $index->references : [$index->references];
+            foreach ($references as $reference) {
+                $dependedColumns[] = "{$index->on}.{$reference}";
+            }
+        }
+
+        return $dependedColumns;
+    }
+
+    public function getAddedColumnNames(): array
+    {
+        return array_map(fn ($column) => $column->name, $this->addedColumns);
+    }
+
+    public function extractForeignKey(string $on, string $reference): Fluent
+    {
+        foreach ($this->addedIndexes as $index) {
+            $references = is_array($index->references) ? $index->references : [$index->references];
+            if (
+                IndexType::Foreign->value !== $index->name ||
+                $index->on !== $on ||
+                !in_array($reference, $index->references)
+            ) {
+                continue;
+            }
+
+            $this->addedIndexes = array_filter($this->addedIndexes, fn($i) => $i->index !== $index->index);
+            return $index;
+        }
+
+        throw new Exception("Reference {$on}.{$reference} has no foreign key in blueprint for {$this->to->getTable()}");
+    }
 }
diff --git a/src/Blueprint/Migratable.php b/src/Blueprint/Migratable.php
@@ -0,0 +1,14 @@
+<?php
+
+namespace Toramanlis\ImplicitMigrations\Blueprint;
+
+use Illuminate\Support\Fluent;
+
+interface Migratable
+{
+    public function getDependedColumnNames(): array;
+
+    public function getAddedColumnNames(): array;
+
+    public function extractForeignKey(string $on, string $reference): Fluent;
+}
diff --git a/src/Blueprint/SimplifyingBlueprint.php b/src/Blueprint/SimplifyingBlueprint.php
@@ -2,14 +2,15 @@
 
 namespace Toramanlis\ImplicitMigrations\Blueprint;
 
+use Exception;
 use Illuminate\Database\Connection;
 use Illuminate\Database\Schema\Blueprint;
 use Illuminate\Support\Facades\App;
 use Illuminate\Support\Facades\DB;
 use Illuminate\Support\Fluent;
 use Toramanlis\ImplicitMigrations\Attributes\IndexType;
 
-class SimplifyingBlueprint extends Blueprint
+class SimplifyingBlueprint extends Blueprint implements Migratable
 {
     public function __construct($tableName, $prefix = '')
     {
@@ -159,4 +160,46 @@ protected function dropIndexCommand($command, $type, $index)
         $this->commands = $remainingCommands;
         return $command;
     }
+
+    public function getDependedColumnNames(): array
+    {
+        $dependedColumnNames = [];
+        foreach ($this->commands as $command) {
+            if (IndexType::Foreign->value !== $command->name) {
+                continue;
+            }
+
+            $references = is_array($command->references) ? $command->references : [$command->references];
+            foreach ($references as $reference) {
+                $dependedColumnNames[] = "{$command->on}.{$reference}";
+            }
+        }
+
+        return $dependedColumnNames;
+    }
+
+    public function getAddedColumnNames(): array
+    {
+        return array_map(fn ($column) => $column->name, $this->columns);
+    }
+
+    public function extractForeignKey(string $on, string $reference): Fluent
+    {
+        foreach ($this->commands as $command) {
+            $references = is_array($command->references) ? $command->references : [$command->references];
+
+            if (
+                IndexType::Foreign->value !== $command->name ||
+                $command->on !== $on ||
+                !in_array($reference, $references)
+            ) {
+                continue;
+            }
+
+            $this->dropForeign($command->index);
+            return $command;
+        }
+
+        throw new Exception("Reference {$on}.{$reference} has no foreign key in blueprint for {$this->getTable()}");
+    }
 }
diff --git a/src/Generator/MigrationGenerator.php b/src/Generator/MigrationGenerator.php
@@ -3,13 +3,14 @@
 namespace Toramanlis\ImplicitMigrations\Generator;
 
 use Illuminate\Database\Schema\Blueprint;
-use Toramanlis\ImplicitMigrations\Blueprint\BlueprintDiff;
 use Toramanlis\ImplicitMigrations\Blueprint\Exporters\TableDiffExporter;
 use Toramanlis\ImplicitMigrations\Blueprint\Exporters\TableExporter;
 use Toramanlis\ImplicitMigrations\Blueprint\Manager;
 use Toramanlis\ImplicitMigrations\Blueprint\SimplifyingBlueprint;
 use Illuminate\Database\Migrations\Migration;
 use Illuminate\Support\Facades\App;
+use Toramanlis\ImplicitMigrations\Blueprint\BlueprintDiff;
+use Toramanlis\ImplicitMigrations\Blueprint\Migratable;
 
 /** @package Toramanlis\ImplicitMigrations\Generator */
 class MigrationGenerator
@@ -73,11 +74,12 @@ public function generate(array $modelNames): array
             $sourceMap[$tableName] = $sourceMap[$tableName] ?? $relationship->getSource();
         }
 
+        $migratables = [];
         foreach ($blueprintManager->getBlueprints() as $table => $blueprint) {
             $blueprint->removeDuplicatePrimaries();
             $source = $sourceMap[$table];
             if (!isset($this->existingBlueprints[$source])) {
-                $migrationData[$table] = $this->getMigrationItem($source, $blueprint);
+                $migratables[$table] = $blueprint;
                 continue;
             }
 
@@ -87,22 +89,183 @@ public function generate(array $modelNames): array
                 continue;
             }
 
-            $migrationData[$this->existingBlueprints[$source]->getTable()] = $this->getMigrationItem(
-                $source,
-                $diff,
-                MigrationMode::Update
-            );
+            $migratables[$table] = $diff;
+        }
+
+        $migratables = $this->sortMigrations($migratables);
+
+        foreach ($migratables as $table => $migratable) {
+            $source = $sourceMap[$table];
+
+            if ($migratable instanceof SimplifyingBlueprint) {
+                $migrationData[$table] = $this->getMigrationItem($source, $migratable);
+            } else {
+                /** @var BlueprintDiff $migratable */
+                $migratable->applyColumnIndexes();
+                $migratable->applyColumnIndexes(true);
+                $migrationData[$this->existingBlueprints[$source]->getTable()] = $this->getMigrationItem(
+                    $source,
+                    $migratable,
+                );
+            }
         }
 
         return $migrationData;
     }
 
+    /**
+     * @param array<Migratable> $migratables
+     * @return array<Migratable> $migratables
+     */
+    protected function sortMigrations(array $migratables): array
+    {
+        $extraMigratables = $this->separateCodependents($migratables);
+
+        $sorted = [];
+
+        while (count($migratables)) {
+            $dependencyMap = $this->getDependencyMap($migratables);
+
+            foreach (array_keys($migratables) as $table) {
+                $dependencies = $dependencyMap[$table] ?? [];
+
+                $counts = array_map(fn ($item) => count($item), $dependencies);
+                if (0 !== array_sum($counts)) {
+                    continue;
+                }
+
+                $sorted[$table] = $migratables[$table];
+                unset($migratables[$table]);
+            }
+        }
+
+        return array_merge($sorted, $extraMigratables);
+    }
+
+    protected function getDependencyMap($migratables)
+    {
+        $addedColumns = [];
+
+        foreach ($migratables as $table => $migratable) {
+            foreach ($migratable->getAddedColumnNames() as $addedColumn) {
+                $addedColumns["{$table}.{$addedColumn}"] = $table;
+            }
+        }
+
+        $dependencyMap = [];
+        foreach (array_keys($migratables) as $table) {
+            $dependencyMap[$table] = $this->getDependencies($table, $migratables, $addedColumns);
+        }
+
+        return $dependencyMap;
+    }
+
+
+    protected function separateCodependents($migratables): array
+    {
+        $extraMigratables = [];
+
+        while (count($codependents = $this->getCodependents($migratables))) {
+            $biggestDependent = null;
+            $mostDependencies = 0;
+
+            foreach ($codependents as $table => $dependencies) {
+                foreach ($dependencies as $column => $columnDependencies) {
+                    if (count($columnDependencies) <= $mostDependencies) {
+                        continue;
+                    }
+
+                    $mostDependencies = count($columnDependencies);
+                    $biggestDependent = ['table' => $table, 'column' => $column];
+                }
+            }
+
+            [$on, $shortColumn] = explode('.', $biggestDependent['column']);
+            $extraMigratable = App::make(BlueprintDiff::class, [
+                'from' => App::make(SimplifyingBlueprint::class, ['tableName' => $biggestDependent['table']]),
+                'to' => App::make(SimplifyingBlueprint::class, ['tableName' => $biggestDependent['table']]),
+                'modifiedColumns' => [],
+                'droppedColumns' => [],
+                'addedColumns' => [],
+                'droppedIndexes' => [],
+                'renamedIndexes' => [],
+                'addedIndexes' => [],
+                'addedIndexes' => [$migratables[$biggestDependent['table']]->extractForeignKey($on, $shortColumn)],
+            ]);
+            $extraMigratables['_' . $biggestDependent['table']] = $extraMigratable;
+        }
+
+
+        return $extraMigratables;
+    }
+
+    protected function getCodependents($migratables)
+    {
+        $dependencyMap = $this->getDependencyMap($migratables);
+
+        $codependents = [];
+        foreach ($dependencyMap as $table => $dependencies) {
+            foreach ($dependencies as $dependedColumn => $columnDependencies) {
+                foreach ($columnDependencies as $dependency) {
+                    foreach ($dependencyMap[$dependency] as $counterColumn => $subdependencies) {
+                        if (!in_array($table, $subdependencies)) {
+                            continue;
+                        }
+
+                        $codependents[$table] ??= [];
+                        $codependents[$table][$dependedColumn] ??= [];
+                        if (!in_array($dependency, $codependents[$table][$dependedColumn])) {
+                            $codependents[$table][$dependedColumn][] = $dependency;
+                        }
+
+                        $codependents[$dependency] ??= [];
+                        $codependents[$dependency][$counterColumn] ??= [];
+                        if (!in_array($table, $codependents[$dependency][$counterColumn])) {
+                            $codependents[$dependency][$counterColumn][] = $table;
+                        }
+                    }
+                }
+            }
+        }
+
+        return $codependents;
+    }
+
+    protected function getDependencies($table, $migratables, $addedColumns, $chain = []): array
+    {
+        if (in_array($table, $chain)) {
+            return [];
+        }
+
+        $chain = array_merge($chain, [$table]);
+
+        $dependencies = [];
+        $migratable = $migratables[$table];
+        foreach ($migratable->getDependedColumnNames() as $dependedColumn) {
+            if (!isset($addedColumns[$dependedColumn])) {
+                continue;
+            }
+
+            $dependency = $addedColumns[$dependedColumn];
+            $subDependencies = $this->getDependencies($dependency, $migratables, $addedColumns, $chain);
+            $merged = array_unique(array_merge([$dependency], $subDependencies));
+
+            if (1 === count($chain)) {
+                $dependencies[$dependedColumn] = $merged;
+            } else {
+                $dependencies = $merged;
+            }
+        }
+
+        return $dependencies;
+    }
+
     protected function getMigrationItem(
         string $source,
-        Blueprint|BlueprintDiff $definition,
-        MigrationMode $mode = MigrationMode::Create
+        Migratable $definition,
     ) {
         $modelName = explode('::', $source)[0];
+        $mode = $definition instanceof SimplifyingBlueprint ? MigrationMode::Create : MigrationMode::Update;
 
         $exporter = match ($mode) {
             MigrationMode::Create => TableExporter::class,
diff --git a/tests/Unit/Generator/MigrationGeneratorTest.php b/tests/Unit/Generator/MigrationGeneratorTest.php
