MarcinOrlowski\ResponseBuilder\ExceptionHandlerHelper

Complexity

Total Complexity

24

Size/Duplication

Total Lines	220
Duplicated Lines	0 %

Test Coverage

Coverage

100%

Importance

Changes	19
Bugs	0	Features	0

7 Methods

Rating	Name	Duplication	Size	Complexity
A	render()	0	27	4
A	getExceptionHandlerConfig()	0	5	1
A	getExceptionHandlerDefaultConfig()	0	24	1
A	unauthenticated()	0	8	1
A	getErrorMessageForException()	0	13	3
B	processException()	0	39	8
B	error()	0	46	6

<?php
declare(strict_types=1);

namespace MarcinOrlowski\ResponseBuilder;

/**
 * Exception handler using ResponseBuilder to return JSON even in such hard tines
 *
 * @package   MarcinOrlowski\ResponseBuilder
 *
 * @author    Marcin Orlowski <mail (#) marcinOrlowski (.) com>
 * @copyright 2016-2019 Marcin Orlowski
 * @license   http://www.opensource.org/licenses/mit-license.php MIT
 * @link      https://github.com/MarcinOrlowski/laravel-api-response-builder
 */

use Exception;
use Illuminate\Auth\AuthenticationException as AuthException;
use Illuminate\Support\Facades\Config;
use Illuminate\Support\Facades\Lang;
use Illuminate\Validation\ValidationException;
use Symfony\Component\HttpFoundation\Response as HttpResponse;
use Symfony\Component\HttpKernel\Exception\HttpException;

/**
 * Class ExceptionHandlerHelper
 */
class ExceptionHandlerHelper
{
    /**
     * Render an exception into valid API response.
     *
     * @param \Illuminate\Http\Request $request Request object
     * @param \Exception               $ex      Exception
     *
     * @return HttpResponse
     */
    public static function render(/** @scrutinizer ignore-unused */ $request, Exception $ex): HttpResponse
    {
        $result = null;
        $cfg = static::getExceptionHandlerConfig()['map'];

        if ($ex instanceof HttpException) {
            // Check if we have any exception configuration for this particular Http status code.
            // This confing entry is guaranted to exist (at least 'default'). Enforced by tests.
            $http_code = $ex->getStatusCode();
            $ex_cfg = $cfg[ HttpException::class ][ $http_code ] ?? null;
            $ex_cfg = $ex_cfg ?? $cfg[ HttpException::class ]['default'];
            $result = self::processException($ex, $ex_cfg, $http_code);
        } elseif ($ex instanceof ValidationException) {
            // This entry is guaranted to exist. Enforced by tests.
            $http_code = HttpResponse::HTTP_UNPROCESSABLE_ENTITY;
            $ex_cfg = $cfg[ HttpException::class ][ $http_code ];
            $result = self::processException($ex, $ex_cfg, $http_code);
        }

        if ($result === null) {
            // This entry is guaranted to exist. Enforced by tests.
            $http_code = HttpResponse::HTTP_INTERNAL_SERVER_ERROR;
            $ex_cfg = $cfg['default'];
            $result = self::processException($ex, $ex_cfg, $http_code);
        }

        return $result;
    }

    protected static function processException(\Exception $ex, array $ex_cfg, int $http_code)
    {
        $api_code = $ex_cfg['api_code'];
        $http_code = $ex_cfg['http_code'] ?? $http_code;
        $msg_key = $ex_cfg['msg_key'] ?? null;
        $msg_enforce = $ex_cfg['msg_enforce'] ?? false;

        // No message key, let's get exception message and if there's nothing useful, fallback to built-in one.
        $error_message = $ex->getMessage();
        $placeholders = [
            'api_code' => $api_code,
            'message'  => ($error_message !== '') ? $error_message : '???',
        ];

        // shall we enforce error message?
        if ($msg_enforce) {
            // yes, please.
            if ($msg_key === null) {
                // there's no msg_key configured for this exact code, so let's obtain our default message
                $error_message = ($msg_key === null) ? static::getErrorMessageForException($ex, $http_code, $placeholders) : Lang::get($msg_key, $placeholders);
            }
        } else {
            // nothing enforced, handling pipeline: ex_message -> user_defined msg -> http_ex -> default
            if ($error_message === '') {
                $error_message = ($msg_key === null) ? static::getErrorMessageForException($ex, $http_code, $placeholders) : Lang::get($msg_key, $placeholders);
            }
        }

        // Lets' try to build the error response with what we have now
        $result = static::error($ex, $api_code, $http_code, $error_message);

        if ($result === null) {
            $ex_cfg = $cfg[ HttpException::class ][ $http_code ];

The variable $cfg seems to be never defined.

            $api_code = $ex_cfg['api_code'] ?? BaseApiCodes::EX_VALIDATION_EXCEPTION();

The function MarcinOrlowski\ResponseBuilder\BaseApiCodes::EX_VALIDATION_EXCEPTION() has been deprecated: Configure Exception Handler to use your own API code.

            $http_code = $ex_cfg['http_code'] ?? $http_code;
            $result = static::error($ex, $api_code, $http_code, $error_message);
        }

        return $result;
    }

    /**
     * Returns error message for given exception. If exception message is empty, then falls back to
     * `default` handler either for HttpException (if $ex is instance of it), or generic `default`
     * config.
     *
     * @param \Exception $ex
     * @param int        $http_code
     * @param array      $placeholders
     *
     * @return string
     */
    protected static function getErrorMessageForException(\Exception $ex, int $http_code, array $placeholders): string
    {
        // exception message is uselss, lets go deeper
        if ($ex instanceof HttpException) {
            $error_message = Lang::get("response-builder::builder.http_{$http_code}", $placeholders);
        } else {
            // Still got nothing? Fall back to built-in generic message for this type of exception.
            $key = BaseApiCodes::getCodeMessageKey(($ex instanceof HttpException)
                ? BaseApiCodes::EX_HTTP_EXCEPTION() : BaseApiCodes::NO_ERROR_MESSAGE());
            $error_message = Lang::get($key, $placeholders);
        }

        return $error_message;
    }

    /**
     * Convert an authentication exception into an unauthenticated response.
     *
     * @param \Illuminate\Http\Request                 $request
     * @param \Illuminate\Auth\AuthenticationException $exception
     *
     * @return HttpResponse
     */
    protected function unauthenticated(/** @scrutinizer ignore-unused */ $request,
                                                                         AuthException $exception): HttpResponse
    {
        // This entry is guaranted to exist. Enforced by tests.
        $http_code = HttpResponse::HTTP_UNAUTHORIZED;
        $cfg = static::getExceptionHandlerConfig()['map'][ HttpException::class ][ $http_code ];

        return static::processException($exception, $cfg, $http_code);
    }

    /**
     * Process single error and produce valid API response.
     *
     * @param Exception $ex Exception to be handled.
     * @param integer   $api_code
     * @param integer   $http_code
     *
     * @return HttpResponse
     */
    protected static function error(Exception $ex,
                                    int $api_code, int $http_code = null, string $error_message): HttpResponse
    {
        $ex_http_code = ($ex instanceof HttpException) ? $ex->getStatusCode() : $ex->getCode();
        $http_code = $http_code ?? $ex_http_code;

        // Check if we now have valid HTTP error code for this case or need to make one up.
        // We cannot throw any exception if codes are invalid because we are in Exception Handler already.
        if ($http_code < ResponseBuilder::ERROR_HTTP_CODE_MIN) {
            // Not a valid code, let's try to get the exception status.
            $http_code = $ex_http_code;
        }
        // Can it be considered a valid HTTP error code?
        if ($http_code < ResponseBuilder::ERROR_HTTP_CODE_MIN) {
            // We now handle uncaught exception, so we cannot throw another one if there's
            // something wrong with the configuration, so we try to recover and use built-in
            // codes instead.
            // FIXME: We should log this event as (warning or error?)
            $http_code = ResponseBuilder::DEFAULT_HTTP_CODE_ERROR;
        }

        // If we have trace data debugging enabled, let's gather some debug info and add to the response.
        $debug_data = null;
        if (Config::get(ResponseBuilder::CONF_KEY_DEBUG_EX_TRACE_ENABLED, false)) {
            $debug_data = [
                Config::get(ResponseBuilder::CONF_KEY_DEBUG_EX_TRACE_KEY, ResponseBuilder::KEY_TRACE) => [
                    ResponseBuilder::KEY_CLASS => get_class($ex),
                    ResponseBuilder::KEY_FILE  => $ex->getFile(),
                    ResponseBuilder::KEY_LINE  => $ex->getLine(),
                ],
            ];
        }

        // If this is ValidationException, add all the messages from MessageBag to the data node.
        $data = null;
        if ($ex instanceof ValidationException) {
            /** @var ValidationException $ex */
            $data = [ResponseBuilder::KEY_MESSAGES => $ex->validator->errors()->messages()];
        }

        return ResponseBuilder::asError($api_code)
            ->withMessage($error_message)
            ->withHttpCode($http_code)
            ->withData($data)
            ->withDebugData($debug_data)
            ->build();
    }

    protected
    static function getExceptionHandlerDefaultConfig(): array
    {
        return [
            'map' => [
                HttpException::class => [
                    // used by unauthenticated() to obtain api and http code for the exception
                    HttpResponse::HTTP_UNAUTHORIZED         => [
                        'api_code' => BaseApiCodes::EX_AUTHENTICATION_EXCEPTION(),

The function MarcinOrlowski\ResponseBuilder\BaseApiCodes::EX_AUTHENTICATION_EXCEPTION() has been deprecated: Configure Exception Handler to use your own API code.

                    ],
                    // Required by ValidationException handler
                    HttpResponse::HTTP_UNPROCESSABLE_ENTITY => [
                        'api_code' => BaseApiCodes::EX_VALIDATION_EXCEPTION(),

The function MarcinOrlowski\ResponseBuilder\BaseApiCodes::EX_VALIDATION_EXCEPTION() has been deprecated: Configure Exception Handler to use your own API code.

                    ],
                    // default handler is mandatory. `default` entry MUST have both `api_code` and `http_code` set.
                    'default'                               => [
                        'api_code'  => BaseApiCodes::EX_HTTP_EXCEPTION(),
                        'http_code' => HttpResponse::HTTP_BAD_REQUEST,
                    ],
                ],
                // default handler is mandatory. `default` entry MUST have both `api_code` and `http_code` set.
                'default'            => [
                    'api_code'  => BaseApiCodes::EX_UNCAUGHT_EXCEPTION(),
                    'http_code' => HttpResponse::HTTP_INTERNAL_SERVER_ERROR,
                ],
            ],
        ];
    }

    /**
     * Returns ExceptionHandlerHelper configration array with user configuration merged into built-in defaults.
     *
     * @return array
     */
    protected
    static function getExceptionHandlerConfig(): array
    {
        return Util::mergeConfig(static::getExceptionHandlerDefaultConfig(),
            \Config::get(ResponseBuilder::CONF_KEY_EXCEPTION_HANDLER, []));
    }

}