Move FK constraint handling to adapter layer

- Add disableForeignKeyConstraints/enableForeignKeyConstraints to AdapterInterface
- Implement FK methods in MysqlAdapter (SET FOREIGN_KEY_CHECKS)
- Implement FK methods in SqliteAdapter (PRAGMA foreign_keys)
- Implement FK methods in SqlserverAdapter (drop all FK constraints)
- PostgresAdapter uses no-op methods with CASCADE in dropTable
- Add FK methods to AdapterWrapper for delegation
- Refactor ResetCommand to use adapter methods instead of dialect-specific code

Author: dereuromark

src/Command/ResetCommand.php

@@ -18,14 +18,13 @@
 use Cake\Console\ConsoleIo;
 use Cake\Console\ConsoleOptionParser;
 use Cake\Database\Connection;
-use Cake\Database\Driver\Mysql;
-use Cake\Database\Driver\Postgres;
-use Cake\Database\Driver\Sqlite;
-use Cake\Database\Driver\Sqlserver;
 use Cake\Datasource\ConnectionManager;
 use Cake\Event\EventDispatcherTrait;
 use Migrations\Config\ConfigInterface;
+use Migrations\Db\Adapter\AdapterInterface;
+use Migrations\Db\Adapter\DirectActionInterface;
 use Migrations\Migration\ManagerFactory;
+use RuntimeException;
 use Throwable;
 
 /**
@@ -149,7 +148,15 @@ public function execute(Arguments $args, ConsoleIo $io): ?int
         // Drop tables
         $io->out('');
         if (!$dryRun) {
-            $this->dropTables($connection, $tablesToDrop, $io);
+            $factory = new ManagerFactory([
+                'plugin' => $args->getOption('plugin'),
+                'source' => $args->getOption('source'),
+                'connection' => $args->getOption('connection'),
+            ]);
+            $manager = $factory->createManager($io);
+            $adapter = $manager->getEnvironment()->getAdapter();
+
+            $this->dropTables($adapter, $tablesToDrop, $io);
         } else {
             $io->info('DRY-RUN: Would drop ' . count($tablesToDrop) . ' table(s).');
         }
@@ -182,104 +189,31 @@ protected function getTablesToDrop(Connection $connection): array
     /**
      * Drop tables with foreign key handling.
      *
-     * @param \Cake\Database\Connection $connection Database connection
+     * @param \Migrations\Db\Adapter\AdapterInterface $adapter The adapter
      * @param array<string> $tables Tables to drop
      * @param \Cake\Console\ConsoleIo $io Console IO
      * @return void
      */
-    protected function dropTables(Connection $connection, array $tables, ConsoleIo $io): void
+    protected function dropTables(AdapterInterface $adapter, array $tables, ConsoleIo $io): void
     {
-        $driver = $connection->getDriver();
+        if (!$adapter instanceof DirectActionInterface) {
+            throw new RuntimeException('The adapter must implement DirectActionInterface');
+        }
 
-        // For PostgreSQL and SQL Server, we need to drop foreign keys first
-        // or use CASCADE in the drop statement
-        if ($driver instanceof Postgres) {
-            foreach ($tables as $table) {
-                $quotedTable = $driver->quoteIdentifier($table);
-                $io->verbose("Dropping table: {$table}");
-                $connection->execute("DROP TABLE IF EXISTS {$quotedTable} CASCADE");
-            }
-        } elseif ($driver instanceof Sqlserver) {
-            // Drop all foreign key constraints first
-            $this->dropForeignKeyConstraints($connection, $tables, $io);
+        $adapter->disableForeignKeyConstraints();
 
-            // Then drop tables
+        try {
             foreach ($tables as $table) {
-                $quotedTable = $driver->quoteIdentifier($table);
                 $io->verbose("Dropping table: {$table}");
-                $connection->execute("DROP TABLE IF EXISTS {$quotedTable}");
-            }
-        } else {
-            // MySQL and SQLite support disabling foreign key checks
-            $this->setForeignKeyChecks($connection, false);
-
-            try {
-                foreach ($tables as $table) {
-                    $quotedTable = $driver->quoteIdentifier($table);
-                    $io->verbose("Dropping table: {$table}");
-                    $connection->execute("DROP TABLE IF EXISTS {$quotedTable}");
-                }
-            } finally {
-                $this->setForeignKeyChecks($connection, true);
+                $adapter->dropTable($table);
             }
+        } finally {
+            $adapter->enableForeignKeyConstraints();
         }
 
         $io->success('Dropped ' . count($tables) . ' table(s).');
     }
 
-    /**
-     * Drop all foreign key constraints from the given tables.
-     *
-     * @param \Cake\Database\Connection $connection Database connection
-     * @param array<string> $tables Tables to process
-     * @param \Cake\Console\ConsoleIo $io Console IO
-     * @return void
-     */
-    protected function dropForeignKeyConstraints(Connection $connection, array $tables, ConsoleIo $io): void
-    {
-        $driver = $connection->getDriver();
-
-        if (!$driver instanceof Sqlserver) {
-            return;
-        }
-
-        // Query to find all foreign key constraints on the specified tables
-        $tableList = implode("','", array_map(fn($t) => addslashes($t), $tables));
-
-        $sql = "SELECT
-                    fk.name AS constraint_name,
-                    OBJECT_NAME(fk.parent_object_id) AS table_name
-                FROM sys.foreign_keys fk
-                WHERE OBJECT_NAME(fk.parent_object_id) IN ('{$tableList}')";
-
-        $result = $connection->execute($sql)->fetchAll('assoc');
-
-        foreach ($result as $row) {
-            $constraintName = $driver->quoteIdentifier($row['constraint_name']);
-            $tableName = $driver->quoteIdentifier($row['table_name']);
-            $io->verbose("Dropping foreign key: {$row['constraint_name']} on {$row['table_name']}");
-            $connection->execute("ALTER TABLE {$tableName} DROP CONSTRAINT {$constraintName}");
-        }
-    }
-
-    /**
-     * Enable or disable foreign key checks.
-     *
-     * @param \Cake\Database\Connection $connection Database connection
-     * @param bool $enable Whether to enable or disable
-     * @return void
-     */
-    protected function setForeignKeyChecks(Connection $connection, bool $enable): void
-    {
-        $driver = $connection->getDriver();
-
-        if ($driver instanceof Mysql) {
-            $connection->execute('SET FOREIGN_KEY_CHECKS = ' . ($enable ? '1' : '0'));
-        } elseif ($driver instanceof Sqlite) {
-            $connection->execute('PRAGMA foreign_keys = ' . ($enable ? 'ON' : 'OFF'));
-        }
-    }
-
     /**
      * Run migrations and dispatch afterReset event.
      *

src/Db/Adapter/AdapterInterface.php

@@ -553,6 +553,26 @@ public function createTable(TableMetadata $table, array $columns = [], array $in
      */
     public function truncateTable(string $tableName): void;
 
+    /**
+     * Disable foreign key constraint checking.
+     *
+     * This is useful when dropping tables or performing bulk operations
+     * that would otherwise fail due to foreign key constraints.
+     *
+     * @return void
+     */
+    public function disableForeignKeyConstraints(): void;
+
+    /**
+     * Enable foreign key constraint checking.
+     *
+     * This should be called after disableForeignKeyConstraints() to
+     * restore normal constraint checking behavior.
+     *
+     * @return void
+     */
+    public function enableForeignKeyConstraints(): void;
+
     /**
      * Returns table columns
      *

src/Db/Adapter/AdapterWrapper.php

@@ -590,4 +590,20 @@ public function getSchemaTableName(): string
     {
         return $this->getAdapter()->getSchemaTableName();
     }
+
+    /**
+     * @inheritDoc
+     */
+    public function disableForeignKeyConstraints(): void
+    {
+        $this->getAdapter()->disableForeignKeyConstraints();
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function enableForeignKeyConstraints(): void
+    {
+        $this->getAdapter()->enableForeignKeyConstraints();
+    }
 }

src/Db/Adapter/MysqlAdapter.php

@@ -560,6 +560,22 @@ public function truncateTable(string $tableName): void
         $this->execute($sql);
     }
 
+    /**
+     * @inheritDoc
+     */
+    public function disableForeignKeyConstraints(): void
+    {
+        $this->execute('SET FOREIGN_KEY_CHECKS = 0');
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function enableForeignKeyConstraints(): void
+    {
+        $this->execute('SET FOREIGN_KEY_CHECKS = 1');
+    }
+
     /**
      * Convert from cakephp/database conventions to migrations\column
      *

src/Db/Adapter/PostgresAdapter.php

@@ -333,7 +333,7 @@ protected function getRenameTableInstructions(string $tableName, string $newTabl
     protected function getDropTableInstructions(string $tableName): AlterInstructions
     {
         $this->removeCreatedTable($tableName);
-        $sql = sprintf('DROP TABLE %s', $this->quoteTableName($tableName));
+        $sql = sprintf('DROP TABLE %s CASCADE', $this->quoteTableName($tableName));
 
         return new AlterInstructions([], [$sql]);
     }
@@ -351,6 +351,24 @@ public function truncateTable(string $tableName): void
         $this->execute($sql);
     }
 
+    /**
+     * @inheritDoc
+     */
+    public function disableForeignKeyConstraints(): void
+    {
+        // PostgreSQL uses CASCADE on DROP TABLE instead of disabling FK checks.
+        // This method is a no-op for PostgreSQL since dropTable already uses CASCADE.
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function enableForeignKeyConstraints(): void
+    {
+        // PostgreSQL uses CASCADE on DROP TABLE instead of disabling FK checks.
+        // This method is a no-op for PostgreSQL.
+    }
+
     /**
      * @inheritDoc
      */

src/Db/Adapter/SqliteAdapter.php

@@ -408,6 +408,22 @@ public function truncateTable(string $tableName): void
         }
     }
 
+    /**
+     * @inheritDoc
+     */
+    public function disableForeignKeyConstraints(): void
+    {
+        $this->execute('PRAGMA foreign_keys = OFF');
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function enableForeignKeyConstraints(): void
+    {
+        $this->execute('PRAGMA foreign_keys = ON');
+    }
+
     /**
      * Parses a default-value expression to yield either a Literal representing
      * a string value, a string representing an expression, or some other scalar

src/Db/Adapter/SqlserverAdapter.php

@@ -280,6 +280,40 @@ public function truncateTable(string $tableName): void
         $this->execute($sql);
     }
 
+    /**
+     * @inheritDoc
+     */
+    public function disableForeignKeyConstraints(): void
+    {
+        // SQL Server doesn't support disabling FK checks globally.
+        // We drop all foreign key constraints instead.
+        $sql = "SELECT
+                    fk.name AS constraint_name,
+                    SCHEMA_NAME(t.schema_id) AS schema_name,
+                    t.name AS table_name
+                FROM sys.foreign_keys fk
+                INNER JOIN sys.tables t ON fk.parent_object_id = t.object_id
+                WHERE SCHEMA_NAME(t.schema_id) = ?";
+
+        $rows = $this->query($sql, [$this->schema])->fetchAll('assoc');
+
+        foreach ($rows as $row) {
+            $constraintName = $this->quoteColumnName($row['constraint_name']);
+            $tableName = $this->quoteTableName($row['table_name']);
+            $this->execute("ALTER TABLE {$tableName} DROP CONSTRAINT {$constraintName}");
+        }
+    }
+
+    /**
+     * @inheritDoc
+     */
+    public function enableForeignKeyConstraints(): void
+    {
+        // SQL Server FK constraints were dropped, not disabled.
+        // They would need to be recreated, but after a reset/drop operation
+        // the tables will be recreated with their constraints by migrations.
+    }
+
     /**
      * @param string $tableName Table name
      * @param ?string $columnName Column name