Make parsers configurable

Author: a-melnikov

src/DependencyInjection/Compiler/ConfigParserPass.php

@@ -36,21 +36,34 @@
 
 class ConfigParserPass implements CompilerPassInterface
 {
+    public const TYPE_YAML = 'yaml';
+    public const TYPE_GRAPHQL = 'graphql';
+    public const TYPE_ANNOTATION = 'annotation';
+    public const TYPE_ATTRIBUTE = 'attribute';
+
+    public const SUPPORTED_TYPES = [
+        self::TYPE_YAML,
+        self::TYPE_GRAPHQL,
+        self::TYPE_ANNOTATION,
+        self::TYPE_ATTRIBUTE,
+    ];
+
     public const SUPPORTED_TYPES_EXTENSIONS = [
-        'yaml' => '{yaml,yml}',
-        'graphql' => '{graphql,graphqls}',
-        'annotation' => 'php',
-        'attribute' => 'php',
+        self::TYPE_YAML => '{yaml,yml}',
+        self::TYPE_GRAPHQL => '{graphql,graphqls}',
+        self::TYPE_ANNOTATION => 'php',
+        self::TYPE_ATTRIBUTE => 'php',
     ];
 
     /**
+     * @deprecated They are going to be configurable.
      * @var array<string, class-string<ParserInterface|PreParserInterface>>
      */
     public const PARSERS = [
-        'yaml' => YamlParser::class,
-        'graphql' => GraphQLParser::class,
-        'annotation' => AnnotationParser::class,
-        'attribute' => AttributeParser::class,
+        self::TYPE_YAML => YamlParser::class,
+        self::TYPE_GRAPHQL => GraphQLParser::class,
+        self::TYPE_ANNOTATION => AnnotationParser::class,
+        self::TYPE_ATTRIBUTE => AttributeParser::class,
     ];
 
     private const DEFAULT_CONFIG = [
@@ -64,6 +77,7 @@ class ConfigParserPass implements CompilerPassInterface
                 'types' => [],
             ],
         ],
+        'parsers' => self::PARSERS,
     ];
 
     /**
@@ -103,7 +117,7 @@ private function getConfigs(ContainerBuilder $container): array
         // Pre-parse all files
         AnnotationParser::reset($config);
         AttributeParser::reset($config);
-        $typesNeedPreParsing = $this->typesNeedPreParsing();
+        $typesNeedPreParsing = $this->typesNeedPreParsing($config['parsers']);
         foreach ($typesMappings as $params) {
             if ($typesNeedPreParsing[$params['type']]) {
                 $this->parseTypeConfigFiles($params['type'], $params['files'], $container, $config, true);
@@ -122,10 +136,15 @@ private function getConfigs(ContainerBuilder $container): array
         return $flattenTypeConfig;
     }
 
-    private function typesNeedPreParsing(): array
+    /**
+     * @param array<string,string> $parsers
+     *
+     * @return array<string,bool>
+     */
+    private function typesNeedPreParsing(array $parsers): array
     {
         $needPreParsing = [];
-        foreach (self::PARSERS as $type => $className) {
+        foreach ($parsers as $type => $className) {
             $needPreParsing[$type] = is_a($className, PreParserInterface::class, true);
         }
 
@@ -152,7 +171,7 @@ private function parseTypeConfigFiles(string $type, iterable $files, ContainerBu
                 continue;
             }
 
-            $parser = [self::PARSERS[$type], $method];
+            $parser = [$configs['parsers'][$type], $method];
             if (is_callable($parser)) {
                 $config[] = ($parser)($file, $container, $configs);
             }

src/DependencyInjection/Configuration.php

@@ -7,6 +7,7 @@
 use GraphQL\Executor\Promise\Adapter\SyncPromiseAdapter;
 use GraphQL\Validator\Rules\QueryComplexity;
 use GraphQL\Validator\Rules\QueryDepth;
+use Overblog\GraphQLBundle\Config\Parser\ParserInterface;
 use Overblog\GraphQLBundle\Definition\Argument;
 use Overblog\GraphQLBundle\DependencyInjection\Compiler\ConfigParserPass;
 use Overblog\GraphQLBundle\Error\ErrorHandler;
@@ -57,6 +58,7 @@ public function getConfigTreeBuilder(): TreeBuilder
                 ->append($this->securitySection())
                 ->append($this->doctrineSection())
                 ->append($this->profilerSection())
+                ->append($this->parsersSection())
             ->end();
 
         return $treeBuilder;
@@ -318,6 +320,32 @@ private function doctrineSection(): ArrayNodeDefinition
         return $node;
     }
 
+    private function parsersSection(): ArrayNodeDefinition
+    {
+        /** @var ArrayNodeDefinition $node */
+        $node = (new TreeBuilder('parsers'))->getRootNode();
+        $node->useAttributeAsKey('name');
+
+        $parserPrototype = $node->scalarPrototype();
+        $parserPrototype->cannotBeEmpty();
+        $parserPrototype->validate()
+            ->ifTrue(static function (string $x): bool {
+                return !is_subclass_of($x, ParserInterface::class, true);
+            })
+            ->thenInvalid(sprintf('Parser MUST implement "%s', ParserInterface::class));
+
+        $node->validate()
+            ->ifTrue(static function (array $x): bool {
+                return (bool) array_diff(array_keys($x), ConfigParserPass::SUPPORTED_TYPES);
+            })
+            ->then(static function (array $x) {
+                $types = implode(', ', array_diff(array_keys($x), ConfigParserPass::SUPPORTED_TYPES));
+                throw new \InvalidArgumentException(sprintf('Configured parsers for not supported types: %s', $types));
+            });
+
+        return $node;
+    }
+
     private function profilerSection(): ArrayNodeDefinition
     {
         $builder = new TreeBuilder('profiler');