Add ForbidMultipleTableCreationsRule for Laravel

Author: Bellangelo

README.md

@@ -58,3 +58,13 @@ Forbids using Laravel’s `after()` column modifier in migrations.
 Using `after()` can force a full table rewrite or long locks (engine-dependent), which is unsafe for large or production tables.
 
 No configuration is required.
+
+---
+
+### ForbidMultipleTableCreationsRule
+
+Forbids creating more than one table in a single Laravel migration.
+
+A table creation is detected via multiple Schema::create() calls inside the same migration.
+
+No configuration is required.

composer.json

@@ -13,7 +13,8 @@
         "squizlabs/php_codesniffer": "^4.0",
         "rector/rector": "^2.3",
         "staabm/annotate-pull-request-from-checkstyle": "^1.8",
-        "illuminate/database": "^8.0 || ^9.0 || ^10.0 || ^11.0 || ^12.0"
+        "illuminate/database": "^8.0 || ^9.0 || ^10.0 || ^11.0 || ^12.0",
+        "illuminate/support": "^12.44"
     },
     "scripts": {
         "test": "phpunit",

extension.neon

@@ -30,5 +30,10 @@ services:
 
     -
         class: PhpStanMigrationRules\Rules\Laravel\ForbidAfterRule
+        tags:
+            - phpstan.rules.rule
+            
+    -
+        class: PhpStanMigrationRules\Rules\Laravel\ForbidMultipleTableCreationsRule
         tags:
             - phpstan.rules.rule

src/Rules/Laravel/ForbidMultipleTableCreationsRule.php

@@ -0,0 +1,79 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpStanMigrationRules\Rules\Laravel;
+
+use PhpParser\Node;
+use PhpParser\Node\Expr\StaticCall;
+use PhpParser\Node\Identifier;
+use PhpParser\Node\Name;
+use PHPStan\Analyser\Scope;
+use PHPStan\Rules\Rule;
+use PHPStan\Rules\RuleErrorBuilder;
+
+/**
+ * @implements Rule<StaticCall>
+ */
+final class ForbidMultipleTableCreationsRule implements Rule
+{
+    private const string RULE_IDENTIFIER = 'laravel.schema.multipleTableCreationsForbidden';
+
+    /**
+     * @var array<string, int>
+     */
+    private array $createCallsPerFile = [];
+
+    public function getNodeType(): string
+    {
+        return StaticCall::class;
+    }
+
+    public function processNode(Node $node, Scope $scope): array
+    {
+        $classReflection = $scope->getClassReflection();
+        if ($classReflection === null) {
+            return [];
+        }
+
+        if (!$classReflection->isSubclassOf(\Illuminate\Database\Migrations\Migration::class)) {
+            return [];
+        }
+
+        if (!$this->isSchemaCreateCall($node, $scope)) {
+            return [];
+        }
+
+        $file = $scope->getFile();
+        $this->createCallsPerFile[$file] = ($this->createCallsPerFile[$file] ?? 0) + 1;
+
+        if ($this->createCallsPerFile[$file] > 1) {
+            return [
+                RuleErrorBuilder::message(
+                    'Creating multiple tables in a single Laravel migration is forbidden. '
+                    . 'Each migration should create exactly one table.'
+                )
+                ->identifier(self::RULE_IDENTIFIER)
+                ->build(),
+            ];
+        }
+
+        return [];
+    }
+
+    private function isSchemaCreateCall(StaticCall $node, Scope $scope): bool
+    {
+        if (!$node->name instanceof Identifier || $node->name->toString() !== 'create') {
+            return false;
+        }
+
+        if (!$node->class instanceof Name) {
+            return false;
+        }
+
+        $resolved = $scope->resolveName($node->class);
+
+        return $resolved === \Illuminate\Support\Facades\Schema::class
+            || $resolved === 'Illuminate\\Database\\Schema\\Schema'; // Rare case
+    }
+}

tests/Rules/Laravel/ForbidAfterRuleTest.php

@@ -42,11 +42,7 @@ public function testReportsAfterInsideCreateClosure(): void
             [
                 [
                     'Using "after()" in migrations is forbidden. It forces a full table rewrite or long locks depending on the engine, which is unsafe for large or production tables.',
-                    25,
-                ],
-                [
-                    'No error to ignore is reported on line 20.',
-                    20,
+                    16,
                 ],
             ]
         );
@@ -58,8 +54,8 @@ public function testDoesNotReportOutsideLaravelMigration(): void
             [__DIR__ . '/fixtures/NonMigrationClass.php'],
             [
                 [
-                    'No error to ignore is reported on line 14.',
-                    14,
+                    'No error to ignore is reported on line 15.',
+                    15,
                 ]
             ],
         );

tests/Rules/Laravel/ForbidMultipleTableCreationsRule.php

@@ -0,0 +1,55 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpStanMigrationRules\Tests\Rules\Laravel;
+
+use PhpStanMigrationRules\Rules\Laravel\ForbidMultipleTableCreationsRule;
+use PHPStan\Rules\Rule;
+use PHPStan\Testing\RuleTestCase;
+
+/**
+ * @extends RuleTestCase<ForbidMultipleTableCreationsRule>
+ */
+final class ForbidMultipleTableCreationsRuleTest extends RuleTestCase
+{
+    protected function getRule(): Rule
+    {
+        return new ForbidMultipleTableCreationsRule();
+    }
+
+    public function testReportsSecondSchemaCreateInMigration(): void
+    {
+        $this->analyse(
+            [__DIR__ . '/Fixtures/ForbidMultipleTableCreations.php'],
+            [
+                [
+                    'Creating multiple tables in a single Laravel migration is forbidden. Each migration should create exactly one table.',
+                    18,
+                    'laravel.schema.multipleTableCreationsForbidden',
+                ],
+            ]
+        );
+    }
+
+    public function testAllowsSingleSchemaCreateInMigration(): void
+    {
+        $this->analyse(
+            [__DIR__ . '/Fixtures/AllowSingleTableCreation.php'],
+            []
+        );
+    }
+
+    public function testDoesNotReportOutsideLaravelMigration(): void
+    {
+        $this->analyse(
+            [__DIR__ . '/fixtures/NonMigrationClass.php'],
+            [
+                [
+                    'No error to ignore is reported on line 14.',
+                    14,
+                ]
+            ],
+        );
+    }
+}

tests/Rules/Laravel/fixtures/AllowSingleTableCreation.php

@@ -0,0 +1,17 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpStanMigrationRules\Tests\Rules\Laravel\Fixtures;
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Support\Facades\Schema;
+
+final class AllowSingleTableCreation extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('users', static function (): void {
+        });
+    }
+}

tests/Rules/Laravel/fixtures/ForbidAfterInCreate.php

@@ -6,22 +6,13 @@
 
 use Illuminate\Database\Migrations\Migration;
 use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
 
 final class ForbidAfterInCreate extends Migration
 {
     public function up(): void
     {
-        // We not have the whole Laravel installed.
-        // Which means that we do not have Facade support.
-        $schema = new class {
-            public function create(string $table, callable $callback): void
-            {
-                /** @phpstan-ignore-next-line */
-                $callback(new Blueprint($table, 'random', null));
-            }
-        };
-
-        $schema->create('users', function (Blueprint $table): void {
+        Schema::create('users', function (Blueprint $table): void {
             $table->string('email')->after('username');
         });
     }

tests/Rules/Laravel/fixtures/ForbidMultipleTableCreations.php

@@ -0,0 +1,19 @@
+<?php
+
+declare(strict_types=1);
+
+namespace PhpStanMigrationRules\Tests\Rules\Laravel\Fixtures;
+
+use Illuminate\Database\Migrations\Migration;
+use Illuminate\Support\Facades\Schema;
+
+final class ForbidMultipleTableCreations extends Migration
+{
+    public function up(): void
+    {
+        Schema::create('users', static function (): void {
+        });
+        Schema::create('courses', static function (): void {
+        });
+    }
+}

tests/Rules/Laravel/fixtures/NonMigrationClass.php

@@ -5,6 +5,7 @@
 namespace PhpStanMigrationRules\Tests\Rules\Laravel\Fixtures;
 
 use Illuminate\Database\Schema\Blueprint;
+use Illuminate\Support\Facades\Schema;
 
 final class NonMigrationClass
 {
@@ -14,5 +15,8 @@ public function run(): void
         $table = new Blueprint('users', 'random', null);
 
         $table->string('email')->after('username');
+
+        Schema::create('users', static function (): void {
+        });
     }
 }