add inheritance exception mapping option

DependencyInjection/Configuration.php

@@ -121,6 +121,7 @@ public function getConfigTreeBuilder()
                                 ->end()
                             ->end()
                         ->end()
+                        ->booleanNode('map_exceptions_to_parent')->defaultFalse()->end()
                         ->arrayNode('exceptions')
                             ->addDefaultsIfNotSet()
                             ->children()

DependencyInjection/OverblogGraphQLExtension.php

@@ -181,6 +181,13 @@ private function setErrorHandlerArguments(array $config, ContainerBuilder $conta
             $errorHandlerDefinition->replaceArgument(0, $config['definitions']['internal_error_message']);
         }
 
+        if (isset($config['definitions']['map_exceptions_to_parent'])) {
+            $errorHandlerDefinition->replaceArgument(
+                3,
+                $config['definitions']['map_exceptions_to_parent']
+            );
+        }
+
         if (isset($config['definitions']['exceptions'])) {
             $errorHandlerDefinition
                 ->replaceArgument(2, $this->buildExceptionMap($config['definitions']['exceptions']))

Error/ErrorHandler.php

@@ -30,14 +30,22 @@ class ErrorHandler
     /** @var string */
     private $userErrorClass = self::DEFAULT_USER_ERROR_CLASS;
 
-    public function __construct($internalErrorMessage = null, LoggerInterface $logger = null, array $exceptionMap = [])
-    {
+    /** @var bool */
+    private $mapExceptionsToParent;
+
+    public function __construct(
+        $internalErrorMessage = null,
+        LoggerInterface $logger = null,
+        array $exceptionMap = [],
+        $mapExceptionsToParent = false
+    ) {
         $this->logger = (null === $logger) ? new NullLogger() : $logger;
         if (empty($internalErrorMessage)) {
             $internalErrorMessage = self::DEFAULT_ERROR_MESSAGE;
         }
         $this->internalErrorMessage = $internalErrorMessage;
         $this->exceptionMap = $exceptionMap;
+        $this->mapExceptionsToParent = $mapExceptionsToParent;
     }
 
     public function setUserWarningClass($userWarningClass)
@@ -170,13 +178,46 @@ protected function convertException($rawException = null)
             return;
         }
 
+        $errorClass = $this->findErrorClass($rawException);
+        if (null !== $errorClass) {
+            return new $errorClass($rawException->getMessage(), $rawException->getCode(), $rawException);
+        }
+
+        return $rawException;
+    }
+
+    /**
+     * @param \Exception|\Error $rawException
+     *
+     * @return string|null
+     */
+    private function findErrorClass($rawException)
+    {
         $rawExceptionClass = get_class($rawException);
         if (isset($this->exceptionMap[$rawExceptionClass])) {
-            $errorClass = $this->exceptionMap[$rawExceptionClass];
+            return $this->exceptionMap[$rawExceptionClass];
+        }
 
-            return new $errorClass($rawException->getMessage(), $rawException->getCode(), $rawException);
+        if ($this->mapExceptionsToParent) {
+            return $this->findErrorClassUsingParentException($rawException);
         }
 
-        return $rawException;
+        return null;
+    }
+
+    /**
+     * @param \Exception|\Error $rawException
+     *
+     * @return string|null
+     */
+    private function findErrorClassUsingParentException($rawException)
+    {
+        foreach ($this->exceptionMap as $rawExceptionClass => $errorClass) {
+            if ($rawException instanceof $rawExceptionClass) {
+                return $errorClass;
+            }
+        }
+
+        return null;
     }
 }

Resources/config/services.yml

@@ -9,6 +9,7 @@ services:
             - ~
             - "@?logger"
             - []
+            - false
 
     overblog_graphql.executor.default:
         class: Overblog\GraphQLBundle\Executor\Executor

Resources/doc/security/errors-handling.md

@@ -108,6 +108,9 @@ overblog_graphql:
     #... 
     definitions:
         #...
+        # change to true to try to map an exception to a parent exception if the exact exception is not in 
+        # the mapping
+        map_exceptions_to_parent: false
         exceptions:
             warnings:
                 - "Symfony\\Component\\Routing\\Exception\\ResourceNotFoundException"

Tests/Error/ChildOfInvalidArgumentException.php

@@ -0,0 +1,9 @@
+<?php
+
+namespace Overblog\GraphQLBundle\Tests\Error;
+
+use InvalidArgumentException;
+
+final class ChildOfInvalidArgumentException extends InvalidArgumentException
+{
+}

Tests/Error/ErrorHandlerTest.php

@@ -158,4 +158,140 @@ public function testConvertExceptionToUserWarning()
 
         $this->assertEquals($expected, $executionResult->toArray());
     }
+
+    /**
+     * @param array        $exceptionMap
+     * @param bool         $mapExceptionsToParent
+     * @param array|string $expectedUserError
+     *
+     * @dataProvider parentExceptionMappingDataProvider
+     */
+    public function testConvertExceptionUsingParentExceptionMatchesAlwaysFirstExactExceptionOtherwiseMatchesParent(array $exceptionMap, $mapExceptionsToParent, $expectedUserError)
+    {
+        $errorHandler = new ErrorHandler(null, null, $exceptionMap, $mapExceptionsToParent);
+
+        $executionResult = new ExecutionResult(
+            null,
+            [
+                new GraphQLError(
+                    'Error with invalid argument exception',
+                    null,
+                    null,
+                    null,
+                    null,
+                    new ChildOfInvalidArgumentException('Invalid argument exception')
+                ),
+            ]
+        );
+
+        if (is_string($expectedUserError)) {
+            self::expectException($expectedUserError);
+        }
+        $errorHandler->handleErrors($executionResult, true);
+
+        if (is_array($expectedUserError)) {
+            $this->assertEquals($expectedUserError, $executionResult->toArray());
+        }
+    }
+
+    /**
+     * @return array
+     */
+    public function parentExceptionMappingDataProvider()
+    {
+        return [
+            'without $mapExceptionsToParent and only the exact class, maps to exact class' => [
+                [
+                    ChildOfInvalidArgumentException::class => UserError::class,
+                ],
+                false,
+                [
+                    'errors' => [
+                        [
+                            'message' => 'Error with invalid argument exception',
+                        ],
+                    ],
+                ],
+            ],
+            'without $mapExceptionsToParent and only the parent class, does not map to parent' => [
+                [
+                    \InvalidArgumentException::class => UserWarning::class,
+                ],
+                false,
+                ChildOfInvalidArgumentException::class,
+            ],
+            'with $mapExceptionsToParent and only the exact class' => [
+                [
+                    ChildOfInvalidArgumentException::class => UserError::class,
+                ],
+                true,
+                [
+                    'errors' => [
+                        [
+                            'message' => 'Error with invalid argument exception',
+                        ],
+                    ],
+                ],
+            ],
+            'with $mapExceptionsToParent and only the parent class' => [
+                [
+                    \InvalidArgumentException::class => UserWarning::class,
+                ],
+                true,
+                [
+                    'extensions' => [
+                        'warnings' => [
+                            [
+                                'message' => 'Error with invalid argument exception',
+                            ],
+                        ],
+                    ],
+                ],
+            ],
+            'with $mapExceptionsToParent and the exact class first matches exact class' => [
+                [
+                    ChildOfInvalidArgumentException::class => UserError::class,
+                    \InvalidArgumentException::class => UserWarning::class,
+                ],
+                true,
+                [
+                    'errors' => [
+                        [
+                            'message' => 'Error with invalid argument exception',
+                        ],
+                    ],
+                ],
+            ],
+            'with $mapExceptionsToParent and the exact class first but parent maps to error' => [
+                [
+                    ChildOfInvalidArgumentException::class => UserWarning::class,
+                    \InvalidArgumentException::class => UserError::class,
+                ],
+                true,
+                [
+                    'extensions' => [
+                        'warnings' => [
+                            [
+                                'message' => 'Error with invalid argument exception',
+                            ],
+                        ],
+                    ],
+                ],
+            ],
+            'with $mapExceptionsToParent and the parent class first still matches exact class' => [
+                [
+                    \InvalidArgumentException::class => UserWarning::class,
+                    ChildOfInvalidArgumentException::class => UserError::class,
+                ],
+                true,
+                [
+                    'errors' => [
+                        [
+                            'message' => 'Error with invalid argument exception',
+                        ],
+                    ],
+                ],
+            ],
+        ];
+    }
 }