feat(core): partial discovery loading (#1737)

Author: brendt

composer.json

@@ -248,6 +248,7 @@
         "fmt": "vendor/bin/mago fmt",
         "lint:fix": "vendor/bin/mago lint --fix --format-after-fix",
         "style": "composer fmt && composer lint:fix",
+        "test": "composer phpunit",
         "lint": "vendor/bin/mago lint --potentially-unsafe --minimum-fail-level=note",
         "phpstan": "vendor/bin/phpstan analyse src tests --memory-limit=1G",
         "rector": "vendor/bin/rector process --no-ansi",

packages/core/src/Commands/DiscoveryGenerateCommand.php

@@ -30,7 +30,11 @@ public function __construct(
             private AppConfig $appConfig,
         ) {}
 
-        #[ConsoleCommand(name: 'discovery:generate', description: 'Compile and cache all discovery according to the configured discovery caching strategy')]
+        #[ConsoleCommand(
+            name: 'discovery:generate',
+            description: 'Compile and cache all discovery according to the configured discovery caching strategy',
+            aliases: ['d:g'],
+        )]
         public function __invoke(): void
         {
             $strategy = DiscoveryCacheStrategy::make(env('DISCOVERY_CACHE', default: $this->appConfig->environment->isProduction()));
@@ -59,7 +63,6 @@ public function generateDiscoveryCache(DiscoveryCacheStrategy $strategy, Closure
             $kernel = $this->resolveKernel();
 
             $loadDiscoveryClasses = new LoadDiscoveryClasses(
-                kernel: $kernel,
                 container: $kernel->container,
                 discoveryConfig: $kernel->container->get(DiscoveryConfig::class),
                 discoveryCache: $this->discoveryCache,

packages/core/src/FrameworkKernel.php

@@ -168,7 +168,10 @@ public function loadDiscoveryLocations(): self
     public function loadDiscovery(): self
     {
         $this->container->addInitializer(DiscoveryCacheInitializer::class);
-        $this->container->invoke(LoadDiscoveryClasses::class);
+        $this->container->invoke(
+            LoadDiscoveryClasses::class,
+            discoveryLocations: $this->discoveryLocations,
+        );
 
         return $this;
     }

packages/core/src/Kernel/LoadDiscoveryClasses.php

@@ -26,52 +26,80 @@ final class LoadDiscoveryClasses
     private array $shouldSkipForClass = [];
 
     public function __construct(
-        private readonly Kernel $kernel,
         private readonly Container $container,
         private readonly DiscoveryConfig $discoveryConfig,
         private readonly DiscoveryCache $discoveryCache,
     ) {}
 
-    public function __invoke(): void
-    {
-        $discoveries = $this->build();
+    /**
+     * @param class-string<Discovery>[]|null $discoveryClasses
+     * @param DiscoveryLocation[]|null $discoveryLocations
+     */
+    public function __invoke(
+        ?array $discoveryClasses = null,
+        ?array $discoveryLocations = null,
+    ): void {
+        $discoveries = $this->build($discoveryClasses, $discoveryLocations);
 
         foreach ($discoveries as $discovery) {
             $this->applyDiscovery($discovery);
         }
     }
 
-    /** @return Discovery[] */
-    public function build(): array
-    {
-        // DiscoveryDiscovery needs to be applied before we can build all other discoveries
-        $discoveryDiscovery = $this->resolveDiscovery(DiscoveryDiscovery::class);
+    /**
+     * @param class-string<Discovery>[]|null $discoveryClasses
+     * @param DiscoveryLocation[]|null $discoveryLocations
+     * @return Discovery[]
+     */
+    public function build(
+        ?array $discoveryClasses = null,
+        ?array $discoveryLocations = null,
+    ): array {
+        $kernel = $this->container->get(Kernel::class);
 
-        // The first pass over all directories to find all discovery classes
-        $this->discover([$discoveryDiscovery]);
+        $discoveryLocations ??= $kernel->discoveryLocations;
 
-        // Manually apply DiscoveryDiscovery
-        $this->applyDiscovery($discoveryDiscovery);
+        if ($discoveryClasses === null) {
+            // DiscoveryDiscovery needs to be applied before we can build all other discoveries
+            $discoveryDiscovery = $this->resolveDiscovery(DiscoveryDiscovery::class);
 
-        // Resolve all other discoveries from the container, optionally loading their cache
-        $discoveries = array_map(
-            fn (string $discoveryClass) => $this->resolveDiscovery($discoveryClass),
-            $this->kernel->discoveryClasses,
-        );
+            // The first pass over all directories to find all discovery classes
+            $this->discover([$discoveryDiscovery], $discoveryLocations);
 
-        // The second pass over all directories to apply all other discovery classes
-        $this->discover($discoveries);
+            // Manually apply DiscoveryDiscovery
+            $this->applyDiscovery($discoveryDiscovery);
 
-        return [$discoveryDiscovery, ...$discoveries];
+            // Resolve all other discoveries from the container, optionally loading their cache
+            $discoveries = array_map(
+                fn (string $discoveryClass) => $this->resolveDiscovery($discoveryClass),
+                $kernel->discoveryClasses,
+            );
+
+            // The second pass over all directories to apply all other discovery classes
+            $this->discover($discoveries, $discoveryLocations);
+
+            return [$discoveryDiscovery, ...$discoveries];
+        } else {
+            // Resolve all manually specified discoveries
+            $discoveries = array_map(
+                fn (string $discoveryClass) => $this->resolveDiscovery($discoveryClass),
+                $discoveryClasses,
+            );
+
+            $this->discover($discoveries, $discoveryLocations);
+
+            return $discoveries;
+        }
     }
 
     /**
      * Build a list of discovery classes within all registered discovery locations
      * @param Discovery[] $discoveries
+     * @param DiscoveryLocation[]|null $discoveryLocations
      */
-    private function discover(array $discoveries): void
+    private function discover(array $discoveries, array $discoveryLocations): void
     {
-        foreach ($this->kernel->discoveryLocations as $location) {
+        foreach ($discoveryLocations as $location) {
             // Skip location based on cache status
             if ($this->isLocationCached($location)) {
                 $cachedForLocation = $this->discoveryCache->restore($location);
@@ -258,7 +286,7 @@ private function shouldSkipDiscoveryForClass(Discovery $discovery, ClassReflecto
             return true;
         }
 
-        // Current discovery was present in the except array, so it shouldn't be skipped
+        // Current discovery was present in the excepted array, so it shouldn't be skipped
         return false;
     }
 

tests/Integration/Core/Fixtures/ManualTestDiscovery.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace Tests\Tempest\Integration\Core\Fixtures;
+
+use Tempest\Discovery\Discovery;
+use Tempest\Discovery\DiscoveryLocation;
+use Tempest\Discovery\IsDiscovery;
+use Tempest\Discovery\SkipDiscovery;
+use Tempest\Reflection\ClassReflector;
+
+#[SkipDiscovery]
+final class ManualTestDiscovery implements Discovery
+{
+    use IsDiscovery;
+
+    private bool $shouldDiscover = false;
+
+    public function __construct(
+        private readonly ManualTestDiscoveryDependency $dependency,
+    ) {}
+
+    public function discover(DiscoveryLocation $location, ClassReflector $class): void
+    {
+        if ($class->getName() === ManualTestDiscoveryDependency::class) {
+            $this->shouldDiscover = true;
+        }
+    }
+
+    public function apply(): void
+    {
+        $this->dependency->discovered = $this->shouldDiscover;
+    }
+}

tests/Integration/Core/Fixtures/ManualTestDiscoveryDependency.php

@@ -0,0 +1,11 @@
+<?php
+
+namespace Tests\Tempest\Integration\Core\Fixtures;
+
+use Tempest\Container\Singleton;
+
+#[Singleton]
+final class ManualTestDiscoveryDependency
+{
+    public bool $discovered = false;
+}

tests/Integration/Core/LoadDiscoveryClassesTest.php

@@ -5,12 +5,16 @@
 namespace Tests\Tempest\Integration\Core;
 
 use PHPUnit\Framework\Attributes\Test;
+use Tempest\Core\Kernel\LoadDiscoveryClasses;
 use Tempest\Database\MigratesUp;
 use Tempest\Database\Migrations\RunnableMigrations;
+use Tempest\Discovery\DiscoveryLocation;
 use Tests\Tempest\Fixtures\Discovery\HiddenDatabaseMigration;
 use Tests\Tempest\Fixtures\Discovery\HiddenMigratableDatabaseMigration;
 use Tests\Tempest\Fixtures\GlobalHiddenDiscovery;
 use Tests\Tempest\Fixtures\GlobalHiddenPathDiscovery;
+use Tests\Tempest\Integration\Core\Fixtures\ManualTestDiscovery;
+use Tests\Tempest\Integration\Core\Fixtures\ManualTestDiscoveryDependency;
 use Tests\Tempest\Integration\FrameworkIntegrationTestCase;
 
 use function Tempest\get;
@@ -52,4 +56,30 @@ public function do_not_discover_except(): void
 
         $this->assertCount(1, $foundMigrations, 'Expected one hidden migration to be found');
     }
+
+    #[Test]
+    public function only_load_specific_discovery_classes(): void
+    {
+        /** @var ManualTestDiscoveryDependency $dependency */
+        $dependency = $this->container->get(ManualTestDiscoveryDependency::class);
+        $dependency->discovered = false;
+
+        /** @var LoadDiscoveryClasses $loadDiscoveryClasses */
+        $loadDiscoveryClasses = $this->container->get(LoadDiscoveryClasses::class);
+
+        $loadDiscoveryClasses(discoveryClasses: [], discoveryLocations: []);
+
+        $this->assertFalse($dependency->discovered);
+
+        $loadDiscoveryClasses(
+            discoveryClasses: [
+                ManualTestDiscovery::class,
+            ],
+            discoveryLocations: [
+                new DiscoveryLocation('Tests\Tempest\Integration\Core\Fixtures', __DIR__ . '/Fixtures'),
+            ],
+        );
+
+        $this->assertTrue($dependency->discovered);
+    }
 }