generate a SchemaCompiledEvent when Type files are generated

UPGRADE-1.0.md

@@ -45,6 +45,7 @@ public function __construct(
     ?string $cacheDir,
     array $configs,
 +   TypeBuilder $typeBuilder
++   EventDispatcherInterface $eventDispatcher
     bool $useClassMap = true,
 -   callable $configProcessor = null,
     ?string $baseCacheDir = null,
@@ -84,4 +85,4 @@ class Argument implements ArgumentInterface
 +   }
 }
 ```
-If you use your own class for resolver arguments, then it should have a `__get` method as well.
+If you use your own class for resolver arguments, then it should have a `__get` method as well.

docs/events/index.md

@@ -186,3 +186,91 @@ class TypeDecorator
   }
 }
 ```
+
+Schema Compiled
+----------------
+
+*Event:* `Overblog\GraphQLBundle\Event\SchemaCompiledEvent`
+
+Used to be notified when the schema has been newly compiled.
+
+Example:
+
+```php
+<?php declare(strict_types=1);
+
+namespace App\Infra\GraphQL\CacheWarmer;
+
+use GraphQL\Utils\SchemaPrinter;
+use Overblog\GraphQLBundle\Event\SchemaCompiledEvent;
+use Overblog\GraphQLBundle\Request\Executor as RequestExecutor;
+use Overblog\GraphQLBundle\Request\ParserInterface;
+use Symfony\Component\Console\Event\ConsoleCommandEvent;
+use Symfony\Component\EventDispatcher\EventSubscriberInterface;
+use Symfony\Component\HttpKernel\Event\RequestEvent;
+
+class GraphQLSchemaDumperSubscriber implements EventSubscriberInterface
+{
+    private RequestExecutor $requestExecutor;
+
+    private string $projectDir;
+
+    private bool $schemaWasRecompiled = false;
+
+    public function __construct(RequestExecutor $requestExecutor, string $projectDir)
+    {
+        $this->requestExecutor = $requestExecutor;
+        $this->projectDir = $projectDir;
+    }
+
+    public function onSchemaCompiled(): void
+    {
+        $this->schemaWasRecompiled = true;
+    }
+
+    public function dumpSchema(): void
+    {
+        if (!$this->schemaWasRecompiled) {
+            return;
+        }
+
+        file_put_contents(
+            "{$this->projectDir}/schema.graphql",
+            SchemaPrinter::doPrint($this->requestExecutor->getSchema()),
+        ) or die("failed to save {$this->projectDir}/schema.graphql");
+
+        $result = $this->requestExecutor
+            ->execute(null, [
+                ParserInterface::PARAM_QUERY => <<<GQL
+                    query {
+                        __schema {
+                            types {
+                                kind
+                                name
+                                possibleTypes {
+                                    name
+                                }
+                            }
+                        }
+                    }
+                GQL,
+                ParserInterface::PARAM_VARIABLES => [],
+            ])
+            ->toArray();
+
+        file_put_contents(
+            "{$this->projectDir}/schema-fragments.json",
+            \json_encode($result, \JSON_PRETTY_PRINT),
+        ) or die("failed to save {$this->projectDir}/schema-fragments.json");
+    }
+
+    public static function getSubscribedEvents()
+    {
+        return [
+            SchemaCompiledEvent::class => "onSchemaCompiled",
+            RequestEvent::class => "dumpSchema",
+            ConsoleCommandEvent::class => "dumpSchema",
+        ];
+    }
+}
+```

src/Event/SchemaCompiledEvent.php

@@ -0,0 +1,11 @@
+<?php
+
+declare(strict_types=1);
+
+namespace Overblog\GraphQLBundle\Event;
+
+use Symfony\Contracts\EventDispatcher\Event;
+
+final class SchemaCompiledEvent extends Event
+{
+}

src/Generator/TypeGenerator.php

@@ -6,7 +6,9 @@
 
 use Composer\Autoload\ClassLoader;
 use Overblog\GraphQLBundle\Config\Processor;
+use Overblog\GraphQLBundle\Event\SchemaCompiledEvent;
 use Symfony\Component\Filesystem\Filesystem;
+use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
 use function array_merge;
 use function file_exists;
 use function file_put_contents;
@@ -33,12 +35,14 @@ class TypeGenerator
     private ?string $baseCacheDir;
     private string $classNamespace;
     private TypeBuilder $typeBuilder;
+    private EventDispatcherInterface $eventDispatcher;
 
     public function __construct(
         string $classNamespace,
         ?string $cacheDir,
         array $configs,
         TypeBuilder $typeBuilder,
+        EventDispatcherInterface $eventDispatcher,
         bool $useClassMap = true,
         ?string $baseCacheDir = null,
         ?int $cacheDirMask = null
@@ -48,6 +52,7 @@ public function __construct(
         $this->useClassMap = $useClassMap;
         $this->baseCacheDir = $baseCacheDir;
         $this->typeBuilder = $typeBuilder;
+        $this->eventDispatcher = $eventDispatcher;
         $this->classNamespace = $classNamespace;
 
         if (null === $cacheDirMask) {
@@ -120,6 +125,8 @@ public function compile(int $mode): array
             $this->loadClasses(true);
         }
 
+        $this->eventDispatcher->dispatch(new SchemaCompiledEvent());
+
         return $classes;
     }
 

src/Resources/config/services.yaml

@@ -64,6 +64,7 @@ services:
             - "%overblog_graphql.cache_dir%"
             - "%overblog_graphql_types.config%"
             - '@Overblog\GraphQLBundle\Generator\TypeBuilder'
+            - '@Symfony\Contracts\EventDispatcher\EventDispatcherInterface'
             - "%overblog_graphql.use_classloader_listener%"
             - "%kernel.cache_dir%"
             - "%overblog_graphql.cache_dir_permissions%"

tests/Generator/TypeGeneratorTest.php

@@ -5,8 +5,10 @@
 namespace Overblog\GraphQLBundle\Tests\Generator;
 
 use Generator;
+use Overblog\GraphQLBundle\Event\SchemaCompiledEvent;
 use Overblog\GraphQLBundle\Generator\TypeBuilder;
 use PHPUnit\Framework\TestCase;
+use Symfony\Contracts\EventDispatcher\EventDispatcherInterface;
 
 class TypeGeneratorTest extends TestCase
 {
@@ -20,14 +22,25 @@ class TypeGeneratorTest extends TestCase
     public function testCacheDirPermissions($expectedMask, $cacheDir, $cacheDirMask): void
     {
         $typeBuilder = $this->createMock(TypeBuilder::class);
+        $eventDispatcher = $this->createMock(EventDispatcherInterface::class);
 
         $mask = (new TypeGenerator(
-            'App', $cacheDir, [], $typeBuilder, true, null, $cacheDirMask
+            'App', $cacheDir, [], $typeBuilder, $eventDispatcher, true, null, $cacheDirMask
         ))->getCacheDirMask();
 
         $this->assertSame($expectedMask, $mask);
     }
 
+    public function testCompiledEvent(): void
+    {
+        $typeBuilder = $this->createMock(TypeBuilder::class);
+        $eventDispatcher = $this->getMockBuilder(EventDispatcherInterface::class)->getMock();
+
+        $eventDispatcher->expects($this->once())->method('dispatch')->with($this->equalTo(new SchemaCompiledEvent()));
+
+        (new TypeGenerator('App', null, [], $typeBuilder, $eventDispatcher))->compile(TypeGenerator::MODE_DRY_RUN);
+    }
+
     public function getPermissionsProvider(): Generator
     {
         // default permission when using default cache dir