OverblogGraphQLExtension::setDefaultFieldResolver() - Code Metrics - Inspection of "Merge pull request #563 from mcg-web/improve-defau..." - overblog/GraphQLBundle - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( 8ac73c...b87729 )

by Jérémiah

created 2019-09-30 09:14 UTC

setDefaultFieldResolver() A

↳ Parent: OverblogGraphQLExtension

Complexity

Conditions	1
Paths	1

Size

Total Lines	3
Code Lines	1

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	2
CRAP Score	1

Importance

Changes

Metric	Value
eloc	1
dl	0
loc	3
ccs	2
cts	2
cp	1
rs	10
c	0
b	0
f	0
cc	1
nc	1
nop	2
crap	1

<?php

declare(strict_types=1);

namespace Overblog\GraphQLBundle\DependencyInjection;

use GraphQL\Error\UserError;
use GraphQL\Type\Definition\Type;
use GraphQL\Type\Schema;
use Overblog\GraphQLBundle\CacheWarmer\CompileCacheWarmer;
use Overblog\GraphQLBundle\Config\Processor\BuilderProcessor;
use Overblog\GraphQLBundle\Definition\Builder\SchemaBuilder;
use Overblog\GraphQLBundle\Definition\Resolver\MutationInterface;
use Overblog\GraphQLBundle\Definition\Resolver\ResolverInterface;
use Overblog\GraphQLBundle\Error\ErrorHandler;
use Overblog\GraphQLBundle\Error\UserWarning;
use Overblog\GraphQLBundle\Event\Events;
use Overblog\GraphQLBundle\EventListener\ClassLoaderListener;
use Overblog\GraphQLBundle\EventListener\DebugListener;
use Overblog\GraphQLBundle\EventListener\ErrorHandlerListener;
use Overblog\GraphQLBundle\EventListener\ErrorLoggerListener;
use Overblog\GraphQLBundle\EventListener\TypeDecoratorListener;
use Overblog\GraphQLBundle\Request\Executor;
use Symfony\Component\Config\FileLocator;
use Symfony\Component\DependencyInjection\ContainerBuilder;
use Symfony\Component\DependencyInjection\ContainerInterface;
use Symfony\Component\DependencyInjection\Loader\YamlFileLoader;
use Symfony\Component\DependencyInjection\Reference;
use Symfony\Component\HttpKernel\DependencyInjection\Extension;

class OverblogGraphQLExtension extends Extension
{
    public function load(array $configs, ContainerBuilder $container): void
    {
        $this->loadConfigFiles($container);
        $configuration = $this->getConfiguration($configs, $container);
        $config = $this->processConfiguration($configuration, $configs);

        $this->setBatchingMethod($config, $container);
        $this->setServicesAliases($config, $container);
        $this->setSchemaBuilderArguments($config, $container);
        $this->setSchemaArguments($config, $container);
        $this->setErrorHandler($config, $container);
        $this->setSecurity($config, $container);
        $this->setConfigBuilders($config, $container);
        $this->setDebugListener($config, $container);
        $this->setDefinitionParameters($config, $container);
        $this->setClassLoaderListener($config, $container);
        $this->setCompilerCacheWarmer($config, $container);
        $this->registerForAutoconfiguration($container);
        $this->setDefaultFieldResolver($config, $container);

        $container->setParameter($this->getAlias().'.config', $config);
        $container->setParameter($this->getAlias().'.resources_dir', \realpath(__DIR__.'/../Resources'));
    }

    public function getAlias()
    {
        return Configuration::NAME;
    }

    public function getConfiguration(array $config, ContainerBuilder $container)
    {
        return new Configuration(
            $container->getParameter('kernel.debug'),
            $container->hasParameter('kernel.cache_dir') ? $container->getParameter('kernel.cache_dir') : null
        );
    }

    private function loadConfigFiles(ContainerBuilder $container): void
    {
        $loader = new YamlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
        $loader->load('services.yaml');
        $loader->load('commands.yaml');
        $loader->load('listeners.yaml');
        $loader->load('graphql_types.yaml');
        $loader->load('graphql_resolvers.yaml');
        $loader->load('expression_language_functions.yaml');
        $loader->load('definition_config_processors.yaml');
        $loader->load('aliases.yaml');
    }

    private function registerForAutoconfiguration(ContainerBuilder $container): void
    {
        $container->registerForAutoconfiguration(MutationInterface::class)
            ->addTag('overblog_graphql.mutation');
        $container->registerForAutoconfiguration(ResolverInterface::class)
            ->addTag('overblog_graphql.resolver');
        $container->registerForAutoconfiguration(Type::class)
            ->addTag('overblog_graphql.type');
    }

    private function setDefaultFieldResolver(array $config, ContainerBuilder $container): void
    {
        $container->setAlias($this->getAlias().'.default_field_resolver', $config['definitions']['default_field_resolver']);
    }

    private function setCompilerCacheWarmer(array $config, ContainerBuilder $container): void
    {
        $container->register(CompileCacheWarmer::class)
            ->setArguments([
                new Reference($this->getAlias().'.cache_compiler'),
                $config['definitions']['auto_compile'],
            ])
            ->addTag('kernel.cache_warmer', ['priority' => 50])
        ;
    }

    private function setClassLoaderListener(array $config, ContainerBuilder $container): void
    {
        $container->setParameter($this->getAlias().'.use_classloader_listener', $config['definitions']['use_classloader_listener']);
        if ($config['definitions']['use_classloader_listener']) {
            $definition = $container->register(
                $this->getAlias().'.event_listener.classloader_listener',
                ClassLoaderListener::class
            );
            $definition->setPublic(true);
            $definition->setArguments([new Reference($this->getAlias().'.cache_compiler')]);
            $definition->addTag('kernel.event_listener', ['event' => 'kernel.request', 'method' => 'load', 'priority' => 255]);
            $definition->addTag('kernel.event_listener', ['event' => 'console.command', 'method' => 'load', 'priority' => 255]);
        }
    }

    private function setDefinitionParameters(array $config, ContainerBuilder $container): void
    {
        // generator and config
        $container->setParameter($this->getAlias().'.class_namespace', $config['definitions']['class_namespace']);
        $container->setParameter($this->getAlias().'.cache_dir', $config['definitions']['cache_dir']);
        $container->setParameter($this->getAlias().'.cache_dir_permissions', $config['definitions']['cache_dir_permissions']);
        $container->setParameter($this->getAlias().'.argument_class', $config['definitions']['argument_class']);
        $container->setParameter($this->getAlias().'.use_experimental_executor', $config['definitions']['use_experimental_executor']);
    }

    private function setBatchingMethod(array $config, ContainerBuilder $container): void
    {
        $container->setParameter($this->getAlias().'.batching_method', $config['batching_method']);
    }

    private function setDebugListener(array $config, ContainerBuilder $container): void
    {
        if ($config['definitions']['show_debug_info']) {
            $definition = $container->register(DebugListener::class);
            $definition->addTag('kernel.event_listener', ['event' => Events::PRE_EXECUTOR, 'method' => 'onPreExecutor']);
            $definition->addTag('kernel.event_listener', ['event' => Events::POST_EXECUTOR, 'method' => 'onPostExecutor']);
        }
    }

    private function setConfigBuilders(array $config, ContainerBuilder $container): void
    {
        foreach (BuilderProcessor::BUILDER_TYPES as $type) {
            if (!empty($config['definitions']['builders'][$type])) {
                foreach ($config['definitions']['builders'][$type] as $params) {
                    $container->addObjectResource($params['class']);
                    BuilderProcessor::addBuilderClass($params['alias'], $type, $params['class']);
                }
            }
        }
    }

    private function setSecurity(array $config, ContainerBuilder $container): void
    {
        $executorDefinition = $container->getDefinition(Executor::class);
        if ($config['security']['enable_introspection']) {
            $executorDefinition->addMethodCall('enableIntrospectionQuery');
        } else {
            $executorDefinition->addMethodCall('disableIntrospectionQuery');
        }

        foreach ($config['security'] as $key => $value) {
            $container->setParameter(\sprintf('%s.%s', $this->getAlias(), $key), $value);
        }
    }

    private function setErrorHandler(array $config, ContainerBuilder $container): void
    {
        if ($config['errors_handler']['enabled']) {
            $id = $this->getAlias().'.error_handler';
            $container->register($id, ErrorHandler::class)
                ->setArguments(
                    [
                        new Reference('event_dispatcher'),
                        $config['errors_handler']['internal_error_message'],
                        $this->buildExceptionMap($config['errors_handler']['exceptions']),
                        $config['errors_handler']['map_exceptions_to_parent'],
                    ]
                );

            $errorHandlerListenerDefinition = $container->register(ErrorHandlerListener::class);
            $errorHandlerListenerDefinition->setPublic(true)
                ->setArguments([new Reference($id), $config['errors_handler']['rethrow_internal_exceptions'], $config['errors_handler']['debug']])
                ->addTag('kernel.event_listener', ['event' => Events::POST_EXECUTOR, 'method' => 'onPostExecutor']);

            if ($config['errors_handler']['log']) {
                $loggerServiceId = $config['errors_handler']['logger_service'];
                $invalidBehavior = ErrorLoggerListener::DEFAULT_LOGGER_SERVICE === $loggerServiceId ? ContainerInterface::NULL_ON_INVALID_REFERENCE : ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE;
                $container->register(ErrorLoggerListener::class)
                    ->setPublic(true)
                    ->setArguments([new Reference($loggerServiceId, $invalidBehavior)])
                    ->addTag('kernel.event_listener', ['event' => Events::ERROR_FORMATTING, 'method' => 'onErrorFormatting']);
            }
        }
    }

    private function setSchemaBuilderArguments(array $config, ContainerBuilder $container): void
    {
        $container->getDefinition(SchemaBuilder::class)
            ->replaceArgument(1, $config['definitions']['config_validation']);
    }

    private function setSchemaArguments(array $config, ContainerBuilder $container): void
    {
        if (isset($config['definitions']['schema'])) {
            $executorDefinition = $container->getDefinition(Executor::class);
            $typeDecoratorListenerDefinition = $container->getDefinition(TypeDecoratorListener::class);

            foreach ($config['definitions']['schema'] as $schemaName => $schemaConfig) {
                // builder
                $schemaBuilderID = \sprintf('%s.schema_builder_%s', $this->getAlias(), $schemaName);
                $definition = $container->register($schemaBuilderID, \Closure::class);
                $definition->setFactory([new Reference('overblog_graphql.schema_builder'), 'getBuilder']);
                $definition->setArguments([
                    $schemaName,
                    $schemaConfig['query'],
                    $schemaConfig['mutation'],
                    $schemaConfig['subscription'],
                    $schemaConfig['types'],
                ]);
                // schema
                $schemaID = \sprintf('%s.schema_%s', $this->getAlias(), $schemaName);
                $definition = $container->register($schemaID, Schema::class);
                $definition->setFactory([new Reference($schemaBuilderID), 'call']);

                if (!empty($schemaConfig['resolver_maps'])) {
                    $typeDecoratorListenerDefinition->addMethodCall(
                        'addSchemaResolverMaps',
                        [
                            $schemaName,
                            \array_map(function ($id) {
                                return new Reference($id);
                            }, $schemaConfig['resolver_maps']),
                        ]
                    );
                }
                $executorDefinition->addMethodCall('addSchemaBuilder', [$schemaName, new Reference($schemaBuilderID)]);
            }
        }
    }

    private function setServicesAliases(array $config, ContainerBuilder $container): void
    {
        if (isset($config['services'])) {
            foreach ($config['services'] as $name => $id) {
                $alias = \sprintf('%s.%s', $this->getAlias(), $name);
                $container->setAlias($alias, $id);
            }
        }
    }

    /**
     * Returns a list of custom exceptions mapped to error/warning classes.
     *
     * @param array $exceptionConfig
     *
     * @return array Custom exception map, [exception => UserError/UserWarning]
     */
    private function buildExceptionMap(array $exceptionConfig)
    {
        $exceptionMap = [];
        $errorsMapping = [
            'errors' => UserError::class,
            'warnings' => UserWarning::class,
        ];

        foreach ($exceptionConfig as $type => $exceptionList) {
            foreach ($exceptionList as $exception) {
                $exceptionMap[$exception] = $errorsMapping[$type];
            }
        }

        return $exceptionMap;
    }
}


1		<?php
2
3		declare(strict_types=1);
4
5		namespace Overblog\GraphQLBundle\DependencyInjection;
6
7		use GraphQL\Error\UserError;
8		use GraphQL\Type\Definition\Type;
9		use GraphQL\Type\Schema;
10		use Overblog\GraphQLBundle\CacheWarmer\CompileCacheWarmer;
11		use Overblog\GraphQLBundle\Config\Processor\BuilderProcessor;
12		use Overblog\GraphQLBundle\Definition\Builder\SchemaBuilder;
13		use Overblog\GraphQLBundle\Definition\Resolver\MutationInterface;
14		use Overblog\GraphQLBundle\Definition\Resolver\ResolverInterface;
15		use Overblog\GraphQLBundle\Error\ErrorHandler;
16		use Overblog\GraphQLBundle\Error\UserWarning;
17		use Overblog\GraphQLBundle\Event\Events;
18		use Overblog\GraphQLBundle\EventListener\ClassLoaderListener;
19		use Overblog\GraphQLBundle\EventListener\DebugListener;
20		use Overblog\GraphQLBundle\EventListener\ErrorHandlerListener;
21		use Overblog\GraphQLBundle\EventListener\ErrorLoggerListener;
22		use Overblog\GraphQLBundle\EventListener\TypeDecoratorListener;
23		use Overblog\GraphQLBundle\Request\Executor;
24		use Symfony\Component\Config\FileLocator;
25		use Symfony\Component\DependencyInjection\ContainerBuilder;
26		use Symfony\Component\DependencyInjection\ContainerInterface;
27		use Symfony\Component\DependencyInjection\Loader\YamlFileLoader;
28		use Symfony\Component\DependencyInjection\Reference;
29		use Symfony\Component\HttpKernel\DependencyInjection\Extension;
30
31		class OverblogGraphQLExtension extends Extension
32		{
33	41	public function load(array $configs, ContainerBuilder $container): void
34		{
35	41	$this->loadConfigFiles($container);
36	41	$configuration = $this->getConfiguration($configs, $container);
37	41	$config = $this->processConfiguration($configuration, $configs);
38
39	41	$this->setBatchingMethod($config, $container);
40	41	$this->setServicesAliases($config, $container);
41	41	$this->setSchemaBuilderArguments($config, $container);
42	41	$this->setSchemaArguments($config, $container);
43	41	$this->setErrorHandler($config, $container);
44	41	$this->setSecurity($config, $container);
45	41	$this->setConfigBuilders($config, $container);
46	41	$this->setDebugListener($config, $container);
47	41	$this->setDefinitionParameters($config, $container);
48	41	$this->setClassLoaderListener($config, $container);
49	41	$this->setCompilerCacheWarmer($config, $container);
50	41	$this->registerForAutoconfiguration($container);
51		$this->setDefaultFieldResolver($config, $container);
52	41
53	41	$container->setParameter($this->getAlias().'.config', $config);
54	41	$container->setParameter($this->getAlias().'.resources_dir', \realpath(__DIR__.'/../Resources'));
55		}
56	41
57		public function getAlias()
58	41	{
59		return Configuration::NAME;
60		}
61	41
62		public function getConfiguration(array $config, ContainerBuilder $container)
63	41	{
64	41	return new Configuration(
65	41	$container->getParameter('kernel.debug'),
66		$container->hasParameter('kernel.cache_dir') ? $container->getParameter('kernel.cache_dir') : null
67		);
68		}
69	41
70		private function loadConfigFiles(ContainerBuilder $container): void
71	41	{
72	41	$loader = new YamlFileLoader($container, new FileLocator(__DIR__.'/../Resources/config'));
73	41	$loader->load('services.yaml');
74	41	$loader->load('commands.yaml');
75	41	$loader->load('listeners.yaml');
76	41	$loader->load('graphql_types.yaml');
77	41	$loader->load('graphql_resolvers.yaml');
78	41	$loader->load('expression_language_functions.yaml');
79	41	$loader->load('definition_config_processors.yaml');
80	41	$loader->load('aliases.yaml');
81		}
82	41
83		private function registerForAutoconfiguration(ContainerBuilder $container): void
84	41	{
85	41	$container->registerForAutoconfiguration(MutationInterface::class)
86	41	->addTag('overblog_graphql.mutation');
87	41	$container->registerForAutoconfiguration(ResolverInterface::class)
88	41	->addTag('overblog_graphql.resolver');
89	41	$container->registerForAutoconfiguration(Type::class)
90	41	->addTag('overblog_graphql.type');
91		}
92	41
93		private function setDefaultFieldResolver(array $config, ContainerBuilder $container): void
94	41	{
95	41	$container->setAlias($this->getAlias().'.default_field_resolver', $config['definitions']['default_field_resolver']);
96	41	}
97	41
98		private function setCompilerCacheWarmer(array $config, ContainerBuilder $container): void
99	41	{
100		$container->register(CompileCacheWarmer::class)
101	41	->setArguments([
102		new Reference($this->getAlias().'.cache_compiler'),
103	41	$config['definitions']['auto_compile'],
104		])
105	41	->addTag('kernel.cache_warmer', ['priority' => 50])
106	41	;
107	40	}
108	40
109	40	private function setClassLoaderListener(array $config, ContainerBuilder $container): void
110		{
111	40	$container->setParameter($this->getAlias().'.use_classloader_listener', $config['definitions']['use_classloader_listener']);
112	40	if ($config['definitions']['use_classloader_listener']) {
113	40	$definition = $container->register(
114	40	$this->getAlias().'.event_listener.classloader_listener',
115		ClassLoaderListener::class
116	41	);
117		$definition->setPublic(true);
118	41	$definition->setArguments([new Reference($this->getAlias().'.cache_compiler')]);
119		$definition->addTag('kernel.event_listener', ['event' => 'kernel.request', 'method' => 'load', 'priority' => 255]);
120		$definition->addTag('kernel.event_listener', ['event' => 'console.command', 'method' => 'load', 'priority' => 255]);
121	41	}
122	41	}
123	41
124	41	private function setDefinitionParameters(array $config, ContainerBuilder $container): void
125	41	{
126	41	// generator and config
127	41	$container->setParameter($this->getAlias().'.class_namespace', $config['definitions']['class_namespace']);
128		$container->setParameter($this->getAlias().'.cache_dir', $config['definitions']['cache_dir']);
129	41	$container->setParameter($this->getAlias().'.cache_dir_permissions', $config['definitions']['cache_dir_permissions']);
130		$container->setParameter($this->getAlias().'.argument_class', $config['definitions']['argument_class']);
131	41	$container->setParameter($this->getAlias().'.use_experimental_executor', $config['definitions']['use_experimental_executor']);
132	41	}
133
134	41	private function setBatchingMethod(array $config, ContainerBuilder $container): void
135		{
136	41	$container->setParameter($this->getAlias().'.batching_method', $config['batching_method']);
137	1	}
138	1
139	1	private function setDebugListener(array $config, ContainerBuilder $container): void
140		{
141	41	if ($config['definitions']['show_debug_info']) {
142		$definition = $container->register(DebugListener::class);
143	41	$definition->addTag('kernel.event_listener', ['event' => Events::PRE_EXECUTOR, 'method' => 'onPreExecutor']);
144		$definition->addTag('kernel.event_listener', ['event' => Events::POST_EXECUTOR, 'method' => 'onPostExecutor']);
145	41	}
146	41	}
147	5
148	5	private function setConfigBuilders(array $config, ContainerBuilder $container): void
149	5	{
150		foreach (BuilderProcessor::BUILDER_TYPES as $type) {
151		if (!empty($config['definitions']['builders'][$type])) {
152		foreach ($config['definitions']['builders'][$type] as $params) {
153	41	$container->addObjectResource($params['class']);
154		BuilderProcessor::addBuilderClass($params['alias'], $type, $params['class']);
155	41	}
156		}
157	41	}
158	41	}
159	40
160		private function setSecurity(array $config, ContainerBuilder $container): void
161	1	{
162		$executorDefinition = $container->getDefinition(Executor::class);
163		if ($config['security']['enable_introspection']) {
164	41	$executorDefinition->addMethodCall('enableIntrospectionQuery');
165	41	} else {
166		$executorDefinition->addMethodCall('disableIntrospectionQuery');
167	41	}
168
169	41	foreach ($config['security'] as $key => $value) {
170		$container->setParameter(\sprintf('%s.%s', $this->getAlias(), $key), $value);
171	41	}
172	41	}
173	41
174	41	private function setErrorHandler(array $config, ContainerBuilder $container): void
175		{
176	41	if ($config['errors_handler']['enabled']) {
177	41	$id = $this->getAlias().'.error_handler';
178	41	$container->register($id, ErrorHandler::class)
179	41	->setArguments(
180		[
181		new Reference('event_dispatcher'),
182		$config['errors_handler']['internal_error_message'],
183	41	$this->buildExceptionMap($config['errors_handler']['exceptions']),
184	41	$config['errors_handler']['map_exceptions_to_parent'],
185	41	]
186	41	);
187
188	41	$errorHandlerListenerDefinition = $container->register(ErrorHandlerListener::class);
189	41	$errorHandlerListenerDefinition->setPublic(true)
190	41	->setArguments([new Reference($id), $config['errors_handler']['rethrow_internal_exceptions'], $config['errors_handler']['debug']])
191	41	->addTag('kernel.event_listener', ['event' => Events::POST_EXECUTOR, 'method' => 'onPostExecutor']);
192	41
193	41	if ($config['errors_handler']['log']) {
194	41	$loggerServiceId = $config['errors_handler']['logger_service'];
195		$invalidBehavior = ErrorLoggerListener::DEFAULT_LOGGER_SERVICE === $loggerServiceId ? ContainerInterface::NULL_ON_INVALID_REFERENCE : ContainerInterface::EXCEPTION_ON_INVALID_REFERENCE;
196		$container->register(ErrorLoggerListener::class)
197	41	->setPublic(true)
198		->setArguments([new Reference($loggerServiceId, $invalidBehavior)])
199	41	->addTag('kernel.event_listener', ['event' => Events::ERROR_FORMATTING, 'method' => 'onErrorFormatting']);
200		}
201	41	}
202	41	}
203	41
204		private function setSchemaBuilderArguments(array $config, ContainerBuilder $container): void
205	41	{
206		$container->getDefinition(SchemaBuilder::class)
207	41	->replaceArgument(1, $config['definitions']['config_validation']);
208	41	}
209	41
210		private function setSchemaArguments(array $config, ContainerBuilder $container): void
211	41	{
212		if (isset($config['definitions']['schema'])) {
213	33	$executorDefinition = $container->getDefinition(Executor::class);
214	33	$typeDecoratorListenerDefinition = $container->getDefinition(TypeDecoratorListener::class);
215	33
216	33	foreach ($config['definitions']['schema'] as $schemaName => $schemaConfig) {
217	33	// builder
218	33	$schemaBuilderID = \sprintf('%s.schema_builder_%s', $this->getAlias(), $schemaName);
219	33	$definition = $container->register($schemaBuilderID, \Closure::class);
220	33	$definition->setFactory([new Reference('overblog_graphql.schema_builder'), 'getBuilder']);
221	33	$definition->setArguments([
222		$schemaName,
223		$schemaConfig['query'],
224	33	$schemaConfig['mutation'],
225	33	$schemaConfig['subscription'],
226	33	$schemaConfig['types'],
227		]);
228	33	// schema
229	1	$schemaID = \sprintf('%s.schema_%s', $this->getAlias(), $schemaName);
230	1	$definition = $container->register($schemaID, Schema::class);
231		$definition->setFactory([new Reference($schemaBuilderID), 'call']);
232	1
233		if (!empty($schemaConfig['resolver_maps'])) {
234	1	$typeDecoratorListenerDefinition->addMethodCall(
235	1	'addSchemaResolverMaps',
236		[
237		$schemaName,
238		\array_map(function ($id) {
239	33	return new Reference($id);
240		}, $schemaConfig['resolver_maps']),
241		]
242	41	);
243		}
244	41	$executorDefinition->addMethodCall('addSchemaBuilder', [$schemaName, new Reference($schemaBuilderID)]);
245		}
246	41	}
247	41	}
248	41
249	41	private function setServicesAliases(array $config, ContainerBuilder $container): void
250		{
251		if (isset($config['services'])) {
252	41	foreach ($config['services'] as $name => $id) {
253		$alias = \sprintf('%s.%s', $this->getAlias(), $name);
254		$container->setAlias($alias, $id);
255		}
256		}
257		}
258
259		/**
260		* Returns a list of custom exceptions mapped to error/warning classes.
261	41	*
262		* @param array $exceptionConfig
263	41	*
264		* @return array Custom exception map, [exception => UserError/UserWarning]
265	41	*/
266		private function buildExceptionMap(array $exceptionConfig)
267		{
268		$exceptionMap = [];
269	41	$errorsMapping = [
270	41	'errors' => UserError::class,
271	2	'warnings' => UserWarning::class,
272		];
273
274		foreach ($exceptionConfig as $type => $exceptionList) {
275	41	foreach ($exceptionList as $exception) {
276		$exceptionMap[$exception] = $errorsMapping[$type];
277		}
278		}
279
280		return $exceptionMap;
281		}
282		}
283

overblog / GraphQLBundle

Scrutinizer GitHub App not installed

Push — master ( 8ac73c...b87729 )

setDefaultFieldResolver() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like