Bump PHPStan to level 8 and fix all errors

composer.json

@@ -24,7 +24,7 @@
     "require": {
         "php": ">=8.2",
         "cakephp/cache": "^5.3.0",
-        "cakephp/database": "^5.3.0",
+        "cakephp/database": "^5.3.2",
         "cakephp/orm": "^5.3.0"
     },
     "require-dev": {

phpstan.neon

@@ -2,7 +2,7 @@ includes:
 	- phpstan-baseline.neon
 
 parameters:
-    level: 7
+    level: 8
     paths:
         - src/
     bootstrapFiles:

src/BaseSeed.php

@@ -278,8 +278,8 @@ protected function runCall(string $seeder, array $options = []): void
 
         $options += [
             'connection' => $connection,
-            'plugin' => $pluginName ?? $config['plugin'],
-            'source' => $config['source'],
+            'plugin' => $pluginName ?? ($config !== null ? $config['plugin'] : null),
+            'source' => $config !== null ? $config['source'] : null,
         ];
         $factory = new ManagerFactory([
             'connection' => $options['connection'],

src/Command/BakeMigrationDiffCommand.php

@@ -27,13 +27,17 @@
 use Cake\Database\Schema\ForeignKey;
 use Cake\Database\Schema\Index;
 use Cake\Database\Schema\TableSchema;
+use Cake\Database\Schema\TableSchemaInterface;
 use Cake\Database\Schema\UniqueKey;
 use Cake\Datasource\ConnectionManager;
 use Cake\Event\Event;
 use Cake\Event\EventManager;
+use Error;
 use Migrations\Migration\ManagerFactory;
 use Migrations\Util\TableFinder;
 use Migrations\Util\UtilTrait;
+use ReflectionException;
+use ReflectionProperty;
 
 /**
  * Task class for generating migration diff files.
@@ -259,7 +263,7 @@ protected function getColumns(): void
             // brand new columns
             $addedColumns = array_diff($currentColumns, $oldColumns);
             foreach ($addedColumns as $columnName) {
-                $column = $currentSchema->getColumn($columnName);
+                $column = $this->safeGetColumn($currentSchema, $columnName);
                 /** @var int $key */
                 $key = array_search($columnName, $currentColumns);
                 if ($key > 0) {
@@ -274,19 +278,28 @@ protected function getColumns(): void
 
             // changes in columns meta-data
             foreach ($currentColumns as $columnName) {
-                $column = $currentSchema->getColumn($columnName);
-                $oldColumn = $this->dumpSchema[$table]->getColumn($columnName);
+                $column = $this->safeGetColumn($currentSchema, $columnName);
+                if ($column === null) {
+                    continue;
+                }
+
+                if (!in_array($columnName, $oldColumns, true)) {
+                    continue;
+                }
+
+                $oldColumn = $this->safeGetColumn($this->dumpSchema[$table], $columnName);
+                if ($oldColumn === null) {
+                    continue;
+                }
+
                 unset(
                     $column['collate'],
                     $column['fixed'],
                     $oldColumn['collate'],
                     $oldColumn['fixed'],
                 );
 
-                if (
-                    in_array($columnName, $oldColumns, true) &&
-                    $column !== $oldColumn
-                ) {
+                if ($column !== $oldColumn) {
                     $changedAttributes = array_diff_assoc($column, $oldColumn);
 
                     foreach (['type', 'length', 'null', 'default'] as $attribute) {
@@ -351,7 +364,7 @@ protected function getColumns(): void
             $removedColumns = array_diff($oldColumns, $currentColumns);
             if ($removedColumns) {
                 foreach ($removedColumns as $columnName) {
-                    $column = $this->dumpSchema[$table]->getColumn($columnName);
+                    $column = $this->safeGetColumn($this->dumpSchema[$table], $columnName);
                     /** @var int $key */
                     $key = array_search($columnName, $oldColumns);
                     if ($key > 0) {
@@ -381,9 +394,10 @@ protected function getConstraints(): void
             // brand new constraints
             $addedConstraints = array_diff($currentConstraints, $oldConstraints);
             foreach ($addedConstraints as $constraintName) {
-                $this->templateData[$table]['constraints']['add'][$constraintName] =
-                    $currentSchema->getConstraint($constraintName);
                 $constraint = $currentSchema->getConstraint($constraintName);
+                if ($constraint === null) {
+                    continue;
+                }
                 if ($constraint['type'] === TableSchema::CONSTRAINT_FOREIGN) {
                     $this->templateData[$table]['constraints']['add'][$constraintName] = $constraint;
                 } else {
@@ -395,13 +409,18 @@ protected function getConstraints(): void
             // if present in both, check if they are the same : if not, remove the old one and add the new one
             foreach ($currentConstraints as $constraintName) {
                 $constraint = $currentSchema->getConstraint($constraintName);
+                if ($constraint === null) {
+                    continue;
+                }
 
+                $oldConstraint = $this->dumpSchema[$table]->getConstraint($constraintName);
                 if (
                     in_array($constraintName, $oldConstraints, true) &&
-                    $constraint !== $this->dumpSchema[$table]->getConstraint($constraintName)
+                    $constraint !== $oldConstraint
                 ) {
-                    $this->templateData[$table]['constraints']['remove'][$constraintName] =
-                        $this->dumpSchema[$table]->getConstraint($constraintName);
+                    if ($oldConstraint !== null) {
+                        $this->templateData[$table]['constraints']['remove'][$constraintName] = $oldConstraint;
+                    }
                     $this->templateData[$table]['constraints']['add'][$constraintName] =
                         $constraint;
                 }
@@ -411,6 +430,9 @@ protected function getConstraints(): void
             $removedConstraints = array_diff($oldConstraints, $currentConstraints);
             foreach ($removedConstraints as $constraintName) {
                 $constraint = $this->dumpSchema[$table]->getConstraint($constraintName);
+                if ($constraint === null) {
+                    continue;
+                }
                 if ($constraint['type'] === TableSchema::CONSTRAINT_FOREIGN) {
                     $this->templateData[$table]['constraints']['remove'][$constraintName] = $constraint;
                 } else {
@@ -621,6 +643,67 @@ public function template(): string
         return 'Migrations.config/diff';
     }
 
+    /**
+     * Safely get column information from a TableSchema.
+     *
+     * This method handles the case where Column::$fixed property may not be
+     * initialized (e.g., when loaded from a cached/serialized schema).
+     *
+     * @param \Cake\Database\Schema\TableSchemaInterface $schema The table schema
+     * @param string $columnName The column name
+     * @return array<string, mixed>|null Column data array or null if column doesn't exist
+     */
+    protected function safeGetColumn(TableSchemaInterface $schema, string $columnName): ?array
+    {
+        try {
+            return $schema->getColumn($columnName);
+        } catch (Error $e) {
+            // Handle uninitialized typed property errors (e.g., Column::$fixed)
+            // This can happen with cached/serialized schema objects
+            if (str_contains($e->getMessage(), 'must not be accessed before initialization')) {
+                // Initialize uninitialized properties using reflection and retry
+                $this->initializeColumnProperties($schema, $columnName);
+
+                return $schema->getColumn($columnName);
+            }
+            throw $e;
+        }
+    }
+
+    /**
+     * Initialize potentially uninitialized Column properties using reflection.
+     *
+     * @param \Cake\Database\Schema\TableSchemaInterface $schema The table schema
+     * @param string $columnName The column name
+     * @return void
+     */
+    protected function initializeColumnProperties(TableSchemaInterface $schema, string $columnName): void
+    {
+        // Access the internal columns array via reflection
+        $reflection = new ReflectionProperty($schema, '_columns');
+        $columns = $reflection->getValue($schema);
+
+        if (!isset($columns[$columnName]) || !($columns[$columnName] instanceof Column)) {
+            return;
+        }
+
+        $column = $columns[$columnName];
+
+        // List of nullable properties that might not be initialized
+        $nullableProperties = ['fixed', 'collate', 'unsigned', 'generated', 'srid', 'onUpdate'];
+
+        foreach ($nullableProperties as $propertyName) {
+            try {
+                $propReflection = new ReflectionProperty(Column::class, $propertyName);
+                if (!$propReflection->isInitialized($column)) {
+                    $propReflection->setValue($column, null);
+                }
+            } catch (Error | ReflectionException) {
+                // Property doesn't exist or can't be accessed, skip it
+            }
+        }
+    }
+
     /**
      * Gets the option parser instance and configures it.
      *

src/Command/BakeSimpleMigrationCommand.php

@@ -52,16 +52,16 @@ abstract class BakeSimpleMigrationCommand extends SimpleBakeCommand
     /**
      * Console IO
      *
-     * @var \Cake\Console\ConsoleIo|null
+     * @var \Cake\Console\ConsoleIo
      */
-    protected ?ConsoleIo $io = null;
+    protected ConsoleIo $io;
 
     /**
      * Arguments
      *
-     * @var \Cake\Console\Arguments|null
+     * @var \Cake\Console\Arguments
      */
-    protected ?Arguments $args = null;
+    protected Arguments $args;
 
     /**
      * @inheritDoc

src/Command/UpgradeCommand.php

@@ -17,6 +17,7 @@
 use Cake\Console\Arguments;
 use Cake\Console\ConsoleIo;
 use Cake\Console\ConsoleOptionParser;
+use Cake\Core\Plugin;
 use Cake\Database\Connection;
 use Cake\Database\Exception\QueryException;
 use Cake\Datasource\ConnectionManager;
@@ -156,10 +157,13 @@ public function execute(Arguments $args, ConsoleIo $io): ?int
             $io->success('Upgrade complete!');
             $io->out('');
             $io->out('Next steps:');
-            $io->out('  1. Set <info>\'Migrations\' => [\'legacyTables\' => false]</info> in your config');
-            $io->out('  2. Test your application');
-            if (!$dropTables) {
-                $io->out('  3. Optionally drop the empty phinxlog tables (re-run `bin/cake migrations upgrade --drop-tables`)');
+            if ($dropTables) {
+                $io->out('  1. Set <info>\'Migrations\' => [\'legacyTables\' => false]</info> in your config');
+                $io->out('  2. Test your application');
+            } else {
+                $io->out('  1. Test your application');
+                $io->out('  2. Drop the phinxlog tables (re-run `bin/cake migrations upgrade --drop-tables`)');
+                $io->out('  3. Set <info>\'Migrations\' => [\'legacyTables\' => false]</info> in your config');
             }
         } else {
             $io->out('');
@@ -181,20 +185,51 @@ protected function findLegacyTables(Connection $connection): array
         $tables = $schema->listTables();
         $legacyTables = [];
 
+        // Build a map of expected table prefixes to plugin names for loaded plugins
+        // This allows matching plugins with special characters like CakeDC/Users
+        $pluginPrefixMap = $this->buildPluginPrefixMap();
+
         foreach ($tables as $table) {
             if ($table === 'phinxlog') {
                 $legacyTables[$table] = null;
             } elseif (str_ends_with($table, '_phinxlog')) {
                 // Extract plugin name from table name
                 $prefix = substr($table, 0, -9); // Remove '_phinxlog'
-                $plugin = Inflector::camelize($prefix);
+
+                // Try to match against loaded plugins first
+                if (isset($pluginPrefixMap[$prefix])) {
+                    $plugin = $pluginPrefixMap[$prefix];
+                } else {
+                    // Fall back to camelizing the prefix
+                    $plugin = Inflector::camelize($prefix);
+                }
                 $legacyTables[$table] = $plugin;
             }
         }
 
         return $legacyTables;
     }
 
+    /**
+     * Build a map of table prefixes to plugin names for all loaded plugins.
+     *
+     * This handles plugins with special characters like CakeDC/Users where
+     * the table prefix is cake_d_c_users but the plugin name is CakeDC/Users.
+     *
+     * @return array<string, string> Map of table prefix => plugin name
+     */
+    protected function buildPluginPrefixMap(): array
+    {
+        $map = [];
+        foreach (Plugin::loaded() as $plugin) {
+            $prefix = Inflector::underscore($plugin);
+            $prefix = str_replace(['\\', '/', '.'], '_', $prefix);
+            $map[$prefix] = $plugin;
+        }
+
+        return $map;
+    }
+
     /**
      * Check if a table exists.
      *

src/Db/Action/ChangeColumn.php

@@ -41,7 +41,7 @@ public function __construct(TableMetadata $table, string $columnName, Column $co
         $this->column = $column;
 
         // if the name was omitted use the existing column name
-        if ($column->getName() === null || strlen((string)$column->getName()) === 0) {
+        if (strlen($column->getName()) === 0) {
             $column->setName($columnName);
         }
     }

src/Db/Adapter/AbstractAdapter.php

@@ -201,6 +201,9 @@ public function getConnection(): Connection
             $this->connection = $this->getOption('connection');
             $this->connect();
         }
+        if ($this->connection === null) {
+            throw new RuntimeException('Unable to establish database connection. Ensure a connection is configured.');
+        }
 
         return $this->connection;
     }
@@ -745,7 +748,7 @@ protected function getUpsertClause(?InsertMode $mode, ?array $updateColumns, ?ar
             return '';
         }
 
-        if ($conflictColumns !== null) {
+        if ($conflictColumns !== null && $conflictColumns !== []) {
             trigger_error(
                 'The $conflictColumns parameter is ignored by MySQL. ' .
                 'MySQL\'s ON DUPLICATE KEY UPDATE applies to all unique constraints on the table.',
@@ -1687,17 +1690,19 @@ public function executeActions(TableMetadata $table, array $actions): void
 
                 case $action instanceof DropForeignKey && $action->getForeignKey()->getName():
                     /** @var \Migrations\Db\Action\DropForeignKey $action */
+                    $fkName = (string)$action->getForeignKey()->getName();
                     $instructions->merge($this->getDropForeignKeyInstructions(
                         $table->getName(),
-                        (string)$action->getForeignKey()->getName(),
+                        $fkName,
                     ));
                     break;
 
                 case $action instanceof DropIndex && $action->getIndex()->getName():
                     /** @var \Migrations\Db\Action\DropIndex $action */
+                    $indexName = (string)$action->getIndex()->getName();
                     $instructions->merge($this->getDropIndexByNameInstructions(
                         $table->getName(),
-                        (string)$action->getIndex()->getName(),
+                        $indexName,
                     ));
                     break;
 
@@ -1720,15 +1725,15 @@ public function executeActions(TableMetadata $table, array $actions): void
                     /** @var \Migrations\Db\Action\RemoveColumn $action */
                     $instructions->merge($this->getDropColumnInstructions(
                         $table->getName(),
-                        (string)$action->getColumn()->getName(),
+                        $action->getColumn()->getName(),
                     ));
                     break;
 
                 case $action instanceof RenameColumn:
                     /** @var \Migrations\Db\Action\RenameColumn $action */
                     $instructions->merge($this->getRenameColumnInstructions(
                         $table->getName(),
-                        (string)$action->getColumn()->getName(),
+                        $action->getColumn()->getName(),
                         $action->getNewName(),
                     ));
                     break;

src/Db/Adapter/AdapterInterface.php

@@ -63,6 +63,7 @@ interface AdapterInterface
 
     // only for mysql so far
     public const TYPE_YEAR = TableSchemaInterface::TYPE_YEAR;
+    public const TYPE_BIT = TableSchemaInterface::TYPE_BIT;
 
     // only for postgresql so far
     public const TYPE_CIDR = TableSchemaInterface::TYPE_CIDR;