MarcinOrlowski / laravel-api-response-builder

src/ResponseBuilder.php

Indentation +508 added lines, -508 removed lines

@@ -24,513 +24,513 @@
  */
 class ResponseBuilder
 {
-    /**
-     * Default HTTP code to be used with success responses
-     *
-     * @var int
-     */
-    public const DEFAULT_HTTP_CODE_OK = HttpResponse::HTTP_OK;
-
-    /**
-     * Default HTTP code to be used with error responses
-     *
-     * @var int
-     */
-    public const DEFAULT_HTTP_CODE_ERROR = HttpResponse::HTTP_BAD_REQUEST;
-
-    /**
-     * Min allowed HTTP code for errorXXX()
-     *
-     * @var int
-     */
-    public const ERROR_HTTP_CODE_MIN = 400;
-
-    /**
-     * Max allowed HTTP code for errorXXX()
-     *
-     * @var int
-     */
-    public const ERROR_HTTP_CODE_MAX = 599;
-
-    /**
-     * Configuration keys
-     */
-    public const CONF_KEY_DEBUG_DEBUG_KEY        = 'response_builder.debug.debug_key';
-    public const CONF_KEY_DEBUG_EX_TRACE_ENABLED = 'response_builder.debug.exception_handler.trace_enabled';
-    public const CONF_KEY_DEBUG_EX_TRACE_KEY     = 'response_builder.debug.exception_handler.trace_key';
-    public const CONF_KEY_MAP                    = 'response_builder.map';
-    public const CONF_KEY_ENCODING_OPTIONS       = 'response_builder.encoding_options';
-    public const CONF_KEY_CLASSES                = 'response_builder.classes';
-    public const CONF_KEY_MIN_CODE               = 'response_builder.min_code';
-    public const CONF_KEY_MAX_CODE               = 'response_builder.max_code';
-    public const CONF_KEY_RESPONSE_KEY_MAP       = 'response_builder.map';
-    public const CONF_EXCEPTION_HANDLER_KEY      = 'response_builder.exception_handler';
-
-    /**
-     * Default keys to be used by exception handler while adding debug information
-     */
-    public const KEY_DEBUG   = 'debug';
-    public const KEY_TRACE   = 'trace';
-    public const KEY_CLASS   = 'class';
-    public const KEY_FILE    = 'file';
-    public const KEY_LINE    = 'line';
-    public const KEY_KEY     = 'key';
-    public const KEY_METHOD  = 'method';
-    public const KEY_SUCCESS = 'success';
-    public const KEY_CODE    = 'code';
-    public const KEY_LOCALE  = 'locale';
-    public const KEY_MESSAGE = 'message';
-    public const KEY_DATA    = 'data';
-
-    /**
-     * Default key to be used by exception handler while processing ValidationException
-     * to return all the error messages
-     *
-     * @var string
-     */
-    public const KEY_MESSAGES = 'messages';
-
-    /**
-     * Default JSON encoding options. Must be specified as final value (i.e. 271) and NOT
-     * PHP expression i.e. `JSON_HEX_TAG|JSON_HEX_APOS|...` as such syntax is not yet supported
-     * by PHP.
-     *
-     * 271 = JSON_HEX_TAG|JSON_HEX_APOS|JSON_HEX_AMP|JSON_HEX_QUOT|JSON_UNESCAPED_UNICODE
-     *
-     * @var int
-     */
-    public const DEFAULT_ENCODING_OPTIONS = 271;
-
-    /**
-     * Reads and validates "classes" config mapping
-     *
-     * @return array Classes mapping as specified in configuration or empty array if configuration found
-     *
-     * @throws \RuntimeException if "classes" mapping is technically invalid (i.e. not array etc).
-     */
-    protected static function getClassesMapping(): ?array
-    {
-        $classes = Config::get(self::CONF_KEY_CLASSES);
-
-        if ($classes !== null) {
-            if (!is_array($classes)) {
-                throw new \RuntimeException(
-                    sprintf('CONFIG: "classes" mapping must be an array (%s given)', gettype($classes)));
-            }
-
-            $mandatory_keys = [
-                static::KEY_KEY,
-                static::KEY_METHOD,
-            ];
-            foreach ($classes as $class_name => $class_config) {
-                foreach ($mandatory_keys as $key_name) {
-                    if (!array_key_exists($key_name, $class_config)) {
-                        throw new \RuntimeException("CONFIG: Missing '{$key_name}' for '{$class_name}' class mapping");
-                    }
-                }
-            }
-        } else {
-            $classes = [];
-        }
-
-        return $classes;
-    }
-
-    /**
-     * Returns success
-     *
-     * @param object|array|null $data          Array of primitives and supported objects to be returned in 'data' node
-     *                                         of the JSON response, single supported object or @null if there's no
-     *                                         to be returned.
-     * @param integer|null      $api_code      API code to be returned or @null to use value of BaseApiCodes::OK().
-     * @param array|null        $placeholders  Placeholders passed to Lang::get() for message placeholders
-     *                                         substitution or @null if none.
-     * @param integer|null      $http_code     HTTP code to be used for HttpResponse sent or @null
-     *                                         for default DEFAULT_HTTP_CODE_OK.
-     * @param integer|null      $json_opts     See http://php.net/manual/en/function.json-encode.php for supported
-     *                                         options or pass @null to use value from your config (or defaults).
-     *
-     * @return HttpResponse
-     */
-    public static function success($data = null, $api_code = null, array $placeholders = null,
-                                   int $http_code = null, int $json_opts = null): HttpResponse
-    {
-        return static::buildSuccessResponse($data, $api_code, $placeholders, $http_code, $json_opts);
-    }
-
-    /**
-     * Returns success
-     *
-     * @param integer|null $api_code      API code to be returned or @null to use value of BaseApiCodes::OK().
-     * @param array|null   $placeholders  Placeholders passed to Lang::get() for message placeholders
-     *                                    substitution or @null if none.
-     * @param integer|null $http_code     HTTP code to be used for HttpResponse sent or @null
-     *                                    for default DEFAULT_HTTP_CODE_OK.
-     *
-     * @return HttpResponse
-     */
-    public static function successWithCode(int $api_code = null, array $placeholders = null,
-                                           int $http_code = null): HttpResponse
-    {
-        return static::success(null, $api_code, $placeholders, $http_code);
-    }
-
-    /**
-     * Returns success with custom HTTP code
-     *
-     * @param integer|null $http_code HTTP return code to be set for this response. If @null is passed, falls back
-     *                                to DEFAULT_HTTP_CODE_OK.
-     *
-     * @return HttpResponse
-     */
-    public static function successWithHttpCode(int $http_code = null): HttpResponse
-    {
-        return static::buildSuccessResponse(null, BaseApiCodes::OK(), [], $http_code);
-    }
-
-    /**
-     * @param object|array|null $data          Array of primitives and supported objects to be returned in 'data' node.
-     *                                         of the JSON response, single supported object or @null if there's no
-     *                                         to be returned.
-     * @param integer|null      $api_code      API code to be returned or @null to use value of BaseApiCodes::OK().
-     * @param array|null        $placeholders  Placeholders passed to Lang::get() for message placeholders
-     *                                         substitution or @null if none.
-     * @param integer|null      $http_code     HTTP code to be used for HttpResponse sent or @null
-     *                                         for default DEFAULT_HTTP_CODE_OK.
-     * @param integer|null      $json_opts     See http://php.net/manual/en/function.json-encode.php for supported
-     *                                         options or pass @null to use value from your config (or defaults).
-     *
-     * @return HttpResponse
-     *
-     * @throws \InvalidArgumentException Thrown when provided arguments are invalid.
-     */
-    protected static function buildSuccessResponse($data = null, int $api_code = null, array $placeholders = null,
-                                                   int $http_code = null, int $json_opts = null): HttpResponse
-    {
-        $http_code = $http_code ?? static::DEFAULT_HTTP_CODE_OK;
-        $api_code = $api_code ?? BaseApiCodes::OK();
-
-        Validator::assertInt('api_code', $api_code);
-        Validator::assertInt('http_code', $http_code);
-        Validator::assertIntRange('http_code', $http_code, 200, 299);
-
-        return static::make(true, $api_code, $api_code, $data, $http_code, $placeholders, null, $json_opts);
-    }
-
-    /**
-     * Builds error Response object. Supports optional arguments passed to Lang::get() if associated error
-     * message uses placeholders as well as return data payload
-     *
-     * @param integer           $api_code      Your API code to be returned with the response object.
-     * @param array|null        $placeholders  Placeholders passed to Lang::get() for message placeholders
-     *                                         substitution or @null if none.
-     * @param object|array|null $data          Array of primitives and supported objects to be returned in 'data' node
-     *                                         of the JSON response, single supported object or @null if there's no
-     *                                         to be returned.
-     * @param integer|null      $http_code     HTTP code to be used for HttpResponse sent or @null
-     *                                         for default DEFAULT_HTTP_CODE_ERROR.
-     * @param integer|null      $json_opts     See http://php.net/manual/en/function.json-encode.php for supported
-     *                                         options or pass @null to use value from your config (or defaults).
-     *
-     * @return HttpResponse
-     */
-    public static function error(int $api_code, array $placeholders = null, $data = null, int $http_code = null,
-                                 int $encoding_options = null): HttpResponse
-    {
-        return static::buildErrorResponse($data, $api_code, $http_code, $placeholders, $encoding_options);
-    }
-
-    /**
-     * @param integer           $api_code      Your API code to be returned with the response object.
-     * @param object|array|null $data          Array of primitives and supported objects to be returned in 'data' node
-     *                                         of the JSON response, single supported object or @null if there's no
-     *                                         to be returned.
-     * @param array|null        $placeholders  Placeholders passed to Lang::get() for message placeholders
-     *                                         substitution or @null if none.
-     * @param integer|null      $json_opts     See http://php.net/manual/en/function.json-encode.php for supported
-     *                                         options or pass @null to use value from your config (or defaults).
-     *
-     * @return HttpResponse
-     */
-    public static function errorWithData(int $api_code, $data, array $placeholders = null,
-                                         int $json_opts = null): HttpResponse
-    {
-        return static::buildErrorResponse($data, $api_code, null, $placeholders, $json_opts);
-    }
-
-    /**
-     * @param integer           $api_code      Your API code to be returned with the response object.
-     * @param object|array|null $data          Array of primitives and supported objects to be returned in 'data' node
-     *                                         of the JSON response, single supported object or @null if there's no
-     *                                         to be returned.
-     * @param integer           $http_code     HTTP code to be used for HttpResponse sent.
-     * @param array|null        $placeholders  Placeholders passed to Lang::get() for message placeholders
-     *                                         substitution or @null if none.
-     * @param integer|null      $json_opts     See http://php.net/manual/en/function.json-encode.php for supported
-     *                                         options or pass @null to use value from your config (or defaults).
-     *
-     * @return HttpResponse
-     *
-     * @throws \InvalidArgumentException if http_code is @null
-     */
-    public static function errorWithDataAndHttpCode(int $api_code, $data, int $http_code, array $placeholders = null,
-                                                    int $json_opts = null): HttpResponse
-    {
-        return static::buildErrorResponse($data, $api_code, $http_code, $placeholders, $json_opts);
-    }
-
-    /**
-     * @param integer    $api_code     Your API code to be returned with the response object.
-     * @param integer    $http_code    HTTP code to be used for HttpResponse sent or @null
-     *                                 for default DEFAULT_HTTP_CODE_ERROR.
-     * @param array|null $placeholders Placeholders passed to Lang::get() for message placeholders
-     *                                 substitution or @null if none.
-     *
-     * @return HttpResponse
-     *
-     * @throws \InvalidArgumentException if http_code is @null
-     */
-    public static function errorWithHttpCode(int $api_code, int $http_code, array $placeholders = null): HttpResponse
-    {
-        return static::buildErrorResponse(null, $api_code, $http_code, $placeholders);
-    }
-
-    /**
-     * @param integer           $api_code  Your API code to be returned with the response object.
-     * @param string            $message   Custom message to be returned as part of error response
-     * @param object|array|null $data      Array of primitives and supported objects to be returned in 'data' node
-     *                                     of the JSON response, single supported object or @null if there's no
-     *                                     to be returned.
-     * @param integer|null      $http_code Optional HTTP status code to be used for HttpResponse sent
-     *                                     or @null for DEFAULT_HTTP_CODE_ERROR
-     * @param integer|null      $json_opts See http://php.net/manual/en/function.json-encode.php for supported
-     *                                     options or pass @null to use value from your config (or defaults).
-     *
-     * @return HttpResponse
-     */
-    public static function errorWithMessageAndData(int $api_code, string $message, $data,
-                                                   int $http_code = null, int $json_opts = null): HttpResponse
-    {
-        return static::buildErrorResponse($data, $api_code, $http_code, null,
-            $message, null, $json_opts);
-    }
-
-    /**
-     * @param integer           $api_code   Your API code to be returned with the response object.
-     * @param string            $message    custom message to be returned as part of error response
-     * @param object|array|null $data       Array of primitives and supported objects to be returned in 'data' node
-     *                                      of the JSON response, single supported object or @null if there's no
-     *                                      to be returned.
-     * @param integer|null      $http_code  HTTP code to be used for HttpResponse sent or @null
-     *                                      for default DEFAULT_HTTP_CODE_ERROR.
-     * @param integer|null      $json_opts  See http://php.net/manual/en/function.json-encode.php for supported
-     *                                      options or pass @null to use value from your config (or defaults).
-     * @param array|null        $debug_data optional debug data array to be added to returned JSON.
-     *
-     * @return HttpResponse
-     */
-    public static function errorWithMessageAndDataAndDebug(int $api_code, string $message, $data,
-                                                           int $http_code = null, int $json_opts = null,
-                                                           array $debug_data = null): HttpResponse
-    {
-        return static::buildErrorResponse($data, $api_code, $http_code, null,
-            $message, null, $json_opts, $debug_data);
-    }
-
-    /**
-     * @param integer      $api_code  Your API code to be returned with the response object.
-     * @param string       $message   Custom message to be returned as part of error response
-     * @param integer|null $http_code HTTP code to be used with final response sent or @null
-     *                                for default DEFAULT_HTTP_CODE_ERROR.
-     *
-     * @return HttpResponse
-     */
-    public static function errorWithMessage(int $api_code, string $message, int $http_code = null): HttpResponse
-    {
-        return static::buildErrorResponse(null, $api_code, $http_code, null, $message);
-    }
-
-    /**
-     * Builds error Response object. Supports optional arguments passed to Lang::get() if associated error message
-     * uses placeholders as well as return data payload
-     *
-     * @param object|array|null $data          Array of primitives and supported objects to be returned in 'data' node
-     *                                         of the JSON response, single supported object or @null if there's no
-     *                                         to be returned.
-     * @param integer           $api_code      Your API code to be returned with the response object.
-     * @param integer|null      $http_code     HTTP code to be used for HttpResponse sent or @null
-     *                                         for default DEFAULT_HTTP_CODE_ERROR.
-     * @param array|null        $placeholders  Placeholders passed to Lang::get() for message placeholders
-     *                                         substitution or @null if none.
-     * @param string|null       $message       custom message to be returned as part of error response
-     * @param array|null        $headers       optional HTTP headers to be returned in error response
-     * @param integer|null      $json_opts     See http://php.net/manual/en/function.json-encode.php for supported
-     *                                         options or pass @null to use value from your config (or defaults).
-     * @param array|null        $debug_data    optional debug data array to be added to returned JSON.
-     *
-     * @return HttpResponse
-     *
-     * @throws \InvalidArgumentException Thrown if $code is not correct, outside the range, equals OK code etc.
-     *
-     * @noinspection MoreThanThreeArgumentsInspection
-     */
-    protected static function buildErrorResponse($data, int $api_code, int $http_code = null,
-                                                 array $placeholders = null,
-                                                 string $message = null, array $headers = null,
-                                                 int $json_opts = null,
-                                                 array $debug_data = null): HttpResponse
-    {
-        $http_code = $http_code ?? static::DEFAULT_HTTP_CODE_ERROR;
-        $headers = $headers ?? [];
-
-        Validator::assertInt('api_code', $api_code);
-
-        $code_ok = BaseApiCodes::OK();
-        if ($api_code !== $code_ok) {
-            Validator::assertIntRange('api_code', $api_code, BaseApiCodes::getMinCode(), BaseApiCodes::getMaxCode());
-        }
-        if ($api_code === $code_ok) {
-            throw new \InvalidArgumentException(
-                "Error response cannot use api_code of value  {$code_ok} which is reserved for OK");
-        }
-
-        Validator::assertInt('http_code', $http_code);
-        Validator::assertIntRange('http_code', $http_code, static::ERROR_HTTP_CODE_MIN, static::ERROR_HTTP_CODE_MAX);
-
-        $msg_or_api_code = $message ?? $api_code;
-
-        return static::make(false, $api_code, $msg_or_api_code, $data, $http_code,
-            $placeholders, $headers, $json_opts, $debug_data);
-    }
-
-    /**
-     * @param boolean           $success         @true if response reports successful operation, @false otherwise.
-     * @param integer           $api_code        Your API code to be returned with the response object.
-     * @param string|integer    $msg_or_api_code message string or valid API code to get message for
-     * @param object|array|null $data            optional additional data to be included in response object
-     * @param integer|null      $http_code       HTTP code for the HttpResponse or @null for either DEFAULT_HTTP_CODE_OK
-     *                                           or DEFAULT_HTTP_CODE_ERROR depending on the $success.
-     * @param array|null        $placeholders    Placeholders passed to Lang::get() for message placeholders
-     *                                           substitution or @null if none.
-     * @param array|null        $headers         Optional HTTP headers to be returned in the response.
-     * @param integer|null      $json_opts       See http://php.net/manual/en/function.json-encode.php for supported
-     *                                           options or pass @null to use value from your config (or defaults).
-     * @param array|null        $debug_data      Optional debug data array to be added to returned JSON.
-     *
-     * @return HttpResponse
-     *
-     * @throws \InvalidArgumentException If $api_code is neither a string nor valid integer code.
-     * @throws \InvalidArgumentException if $data is an object of class that is not configured in "classes" mapping.
-     *
-     * @noinspection MoreThanThreeArgumentsInspection
-     */
-    protected static function make(bool $success, int $api_code, $msg_or_api_code, $data = null,
-                                   int $http_code = null, array $placeholders = null, array $headers = null,
-                                   int $json_opts = null, array $debug_data = null): HttpResponse
-    {
-        $headers = $headers ?? [];
-        $http_code = $http_code ?? ($success ? static::DEFAULT_HTTP_CODE_OK : static::DEFAULT_HTTP_CODE_ERROR);
-        $json_opts = $json_opts ?? Config::get(self::CONF_KEY_ENCODING_OPTIONS, static::DEFAULT_ENCODING_OPTIONS);
-
-        Validator::assertInt('encoding_options', $json_opts);
-
-        Validator::assertInt('api_code', $api_code);
-        if (!BaseApiCodes::isCodeValid($api_code)) {
-            $min = BaseApiCodes::getMinCode();
-            $max = BaseApiCodes::getMaxCode();
-            throw new \InvalidArgumentException("API code value ({$api_code}) is out of allowed range {$min}-{$max}");
-        }
-
-        return Response::json(
-            static::buildResponse($success, $api_code, $msg_or_api_code, $placeholders, $data, $debug_data),
-            $http_code, $headers, $json_opts);
-    }
-
-    /**
-     * If $msg_or_api_code is integer value, returns human readable message associated with that code (with
-     * fallback to built-in default string if no api code mapping is set. If $msg_or_api_code is a string,
-     * returns it unaltered.
-     *
-     * @param boolean    $success      @true if response reports successful operation, @false otherwise.
-     * @param integer    $api_code     Your API code to be returned with the response object.
-     * @param array|null $placeholders Placeholders passed to Lang::get() for message placeholders
-     *                                 substitution or @null if none.
-     *
-     * @return string
-     */
-    protected static function getMessageForApiCode(bool $success, int $api_code, array $placeholders = null): string
-    {
-        // We got integer value here not a message string, so we need to check if we have the mapping for
-        // this string already configured.
-        $key = BaseApiCodes::getCodeMessageKey($api_code);
-        if ($key === null) {
-            // nope, let's get the default one instead, based of
-            $fallback_code = $success ? BaseApiCodes::OK() : BaseApiCodes::NO_ERROR_MESSAGE();
-            $key = BaseApiCodes::getCodeMessageKey($fallback_code);
-        }
-
-        $placeholders = $placeholders ?? [];
-        if (!array_key_exists('api_code', $placeholders)) {
-            $placeholders['api_code'] = $api_code;
-        }
-
-        return \Lang::get($key, $placeholders);
-    }
-
-    /**
-     * Creates standardised API response array. This is final method called in the whole pipeline before we
-     * return final JSON back to client. If you want to manipulate your response, this is the place to do that.
-     * If you set APP_DEBUG to true, 'code_hex' field will be additionally added to reported JSON for easier
-     * manual debugging.
-     *
-     * @param boolean           $success         @true if response reports successful operation, @false otherwise.
-     * @param integer           $api_code        Your API code to be returned with the response object.
-     * @param string|integer    $msg_or_api_code Message string or valid API code to get message for.
-     * @param array|null        $placeholders    Placeholders passed to Lang::get() for message placeholders
-     *                                           substitution or @null if none.
-     * @param object|array|null $data            API response data if any
-     * @param array|null        $debug_data      optional debug data array to be added to returned JSON.
-     *
-     * @return array response ready to be encoded as json and sent back to client
-     *
-     * @throws \RuntimeException in case of missing or invalid "classes" mapping configuration
-     */
-    protected static function buildResponse(bool $success, int $api_code,
-                                            $msg_or_api_code, array $placeholders = null,
-                                            $data = null, array $debug_data = null): array
-    {
-        // ensure $data is either @null, array or object of class with configured mapping.
-        $converter = new Converter();
-
-        $data = $converter->convert($data);
-        if ($data !== null && !is_object($data)) {
-            // ensure we get object in final JSON structure in data node
-            $data = (object)$data;
-        }
-
-        // get human readable message for API code or use message string (if given instead of API code)
-        if (is_int($msg_or_api_code)) {
-            $message = self::getMessageForApiCode($success, $msg_or_api_code, $placeholders);
-        } else {
-            Validator::assertString('message', $msg_or_api_code);
-            $message = $msg_or_api_code;
-        }
-
-        /** @noinspection PhpUndefinedClassInspection */
-        $response = [
-            static::KEY_SUCCESS => $success,
-            static::KEY_CODE    => $api_code,
-            static::KEY_LOCALE  => \App::getLocale(),
-            static::KEY_MESSAGE => $message,
-            static::KEY_DATA    => $data,
-        ];
-
-        if ($debug_data !== null) {
-            $debug_key = Config::get(static::CONF_KEY_DEBUG_DEBUG_KEY, self::KEY_DEBUG);
-            $response[ $debug_key ] = $debug_data;
-        }
-
-        return $response;
-    }
+	/**
+	 * Default HTTP code to be used with success responses
+	 *
+	 * @var int
+	 */
+	public const DEFAULT_HTTP_CODE_OK = HttpResponse::HTTP_OK;
+
+	/**
+	 * Default HTTP code to be used with error responses
+	 *
+	 * @var int
+	 */
+	public const DEFAULT_HTTP_CODE_ERROR = HttpResponse::HTTP_BAD_REQUEST;
+
+	/**
+	 * Min allowed HTTP code for errorXXX()
+	 *
+	 * @var int
+	 */
+	public const ERROR_HTTP_CODE_MIN = 400;
+
+	/**
+	 * Max allowed HTTP code for errorXXX()
+	 *
+	 * @var int
+	 */
+	public const ERROR_HTTP_CODE_MAX = 599;
+
+	/**
+	 * Configuration keys
+	 */
+	public const CONF_KEY_DEBUG_DEBUG_KEY        = 'response_builder.debug.debug_key';
+	public const CONF_KEY_DEBUG_EX_TRACE_ENABLED = 'response_builder.debug.exception_handler.trace_enabled';
+	public const CONF_KEY_DEBUG_EX_TRACE_KEY     = 'response_builder.debug.exception_handler.trace_key';
+	public const CONF_KEY_MAP                    = 'response_builder.map';
+	public const CONF_KEY_ENCODING_OPTIONS       = 'response_builder.encoding_options';
+	public const CONF_KEY_CLASSES                = 'response_builder.classes';
+	public const CONF_KEY_MIN_CODE               = 'response_builder.min_code';
+	public const CONF_KEY_MAX_CODE               = 'response_builder.max_code';
+	public const CONF_KEY_RESPONSE_KEY_MAP       = 'response_builder.map';
+	public const CONF_EXCEPTION_HANDLER_KEY      = 'response_builder.exception_handler';
+
+	/**
+	 * Default keys to be used by exception handler while adding debug information
+	 */
+	public const KEY_DEBUG   = 'debug';
+	public const KEY_TRACE   = 'trace';
+	public const KEY_CLASS   = 'class';
+	public const KEY_FILE    = 'file';
+	public const KEY_LINE    = 'line';
+	public const KEY_KEY     = 'key';
+	public const KEY_METHOD  = 'method';
+	public const KEY_SUCCESS = 'success';
+	public const KEY_CODE    = 'code';
+	public const KEY_LOCALE  = 'locale';
+	public const KEY_MESSAGE = 'message';
+	public const KEY_DATA    = 'data';
+
+	/**
+	 * Default key to be used by exception handler while processing ValidationException
+	 * to return all the error messages
+	 *
+	 * @var string
+	 */
+	public const KEY_MESSAGES = 'messages';
+
+	/**
+	 * Default JSON encoding options. Must be specified as final value (i.e. 271) and NOT
+	 * PHP expression i.e. `JSON_HEX_TAG|JSON_HEX_APOS|...` as such syntax is not yet supported
+	 * by PHP.
+	 *
+	 * 271 = JSON_HEX_TAG|JSON_HEX_APOS|JSON_HEX_AMP|JSON_HEX_QUOT|JSON_UNESCAPED_UNICODE
+	 *
+	 * @var int
+	 */
+	public const DEFAULT_ENCODING_OPTIONS = 271;
+
+	/**
+	 * Reads and validates "classes" config mapping
+	 *
+	 * @return array Classes mapping as specified in configuration or empty array if configuration found
+	 *
+	 * @throws \RuntimeException if "classes" mapping is technically invalid (i.e. not array etc).
+	 */
+	protected static function getClassesMapping(): ?array
+	{
+		$classes = Config::get(self::CONF_KEY_CLASSES);
+
+		if ($classes !== null) {
+			if (!is_array($classes)) {
+				throw new \RuntimeException(
+					sprintf('CONFIG: "classes" mapping must be an array (%s given)', gettype($classes)));
+			}
+
+			$mandatory_keys = [
+				static::KEY_KEY,
+				static::KEY_METHOD,
+			];
+			foreach ($classes as $class_name => $class_config) {
+				foreach ($mandatory_keys as $key_name) {
+					if (!array_key_exists($key_name, $class_config)) {
+						throw new \RuntimeException("CONFIG: Missing '{$key_name}' for '{$class_name}' class mapping");
+					}
+				}
+			}
+		} else {
+			$classes = [];
+		}
+
+		return $classes;
+	}
+
+	/**
+	 * Returns success
+	 *
+	 * @param object|array|null $data          Array of primitives and supported objects to be returned in 'data' node
+	 *                                         of the JSON response, single supported object or @null if there's no
+	 *                                         to be returned.
+	 * @param integer|null      $api_code      API code to be returned or @null to use value of BaseApiCodes::OK().
+	 * @param array|null        $placeholders  Placeholders passed to Lang::get() for message placeholders
+	 *                                         substitution or @null if none.
+	 * @param integer|null      $http_code     HTTP code to be used for HttpResponse sent or @null
+	 *                                         for default DEFAULT_HTTP_CODE_OK.
+	 * @param integer|null      $json_opts     See http://php.net/manual/en/function.json-encode.php for supported
+	 *                                         options or pass @null to use value from your config (or defaults).
+	 *
+	 * @return HttpResponse
+	 */
+	public static function success($data = null, $api_code = null, array $placeholders = null,
+								   int $http_code = null, int $json_opts = null): HttpResponse
+	{
+		return static::buildSuccessResponse($data, $api_code, $placeholders, $http_code, $json_opts);
+	}
+
+	/**
+	 * Returns success
+	 *
+	 * @param integer|null $api_code      API code to be returned or @null to use value of BaseApiCodes::OK().
+	 * @param array|null   $placeholders  Placeholders passed to Lang::get() for message placeholders
+	 *                                    substitution or @null if none.
+	 * @param integer|null $http_code     HTTP code to be used for HttpResponse sent or @null
+	 *                                    for default DEFAULT_HTTP_CODE_OK.
+	 *
+	 * @return HttpResponse
+	 */
+	public static function successWithCode(int $api_code = null, array $placeholders = null,
+										   int $http_code = null): HttpResponse
+	{
+		return static::success(null, $api_code, $placeholders, $http_code);
+	}
+
+	/**
+	 * Returns success with custom HTTP code
+	 *
+	 * @param integer|null $http_code HTTP return code to be set for this response. If @null is passed, falls back
+	 *                                to DEFAULT_HTTP_CODE_OK.
+	 *
+	 * @return HttpResponse
+	 */
+	public static function successWithHttpCode(int $http_code = null): HttpResponse
+	{
+		return static::buildSuccessResponse(null, BaseApiCodes::OK(), [], $http_code);
+	}
+
+	/**
+	 * @param object|array|null $data          Array of primitives and supported objects to be returned in 'data' node.
+	 *                                         of the JSON response, single supported object or @null if there's no
+	 *                                         to be returned.
+	 * @param integer|null      $api_code      API code to be returned or @null to use value of BaseApiCodes::OK().
+	 * @param array|null        $placeholders  Placeholders passed to Lang::get() for message placeholders
+	 *                                         substitution or @null if none.
+	 * @param integer|null      $http_code     HTTP code to be used for HttpResponse sent or @null
+	 *                                         for default DEFAULT_HTTP_CODE_OK.
+	 * @param integer|null      $json_opts     See http://php.net/manual/en/function.json-encode.php for supported
+	 *                                         options or pass @null to use value from your config (or defaults).
+	 *
+	 * @return HttpResponse
+	 *
+	 * @throws \InvalidArgumentException Thrown when provided arguments are invalid.
+	 */
+	protected static function buildSuccessResponse($data = null, int $api_code = null, array $placeholders = null,
+												   int $http_code = null, int $json_opts = null): HttpResponse
+	{
+		$http_code = $http_code ?? static::DEFAULT_HTTP_CODE_OK;
+		$api_code = $api_code ?? BaseApiCodes::OK();
+
+		Validator::assertInt('api_code', $api_code);
+		Validator::assertInt('http_code', $http_code);
+		Validator::assertIntRange('http_code', $http_code, 200, 299);
+
+		return static::make(true, $api_code, $api_code, $data, $http_code, $placeholders, null, $json_opts);
+	}
+
+	/**
+	 * Builds error Response object. Supports optional arguments passed to Lang::get() if associated error
+	 * message uses placeholders as well as return data payload
+	 *
+	 * @param integer           $api_code      Your API code to be returned with the response object.
+	 * @param array|null        $placeholders  Placeholders passed to Lang::get() for message placeholders
+	 *                                         substitution or @null if none.
+	 * @param object|array|null $data          Array of primitives and supported objects to be returned in 'data' node
+	 *                                         of the JSON response, single supported object or @null if there's no
+	 *                                         to be returned.
+	 * @param integer|null      $http_code     HTTP code to be used for HttpResponse sent or @null
+	 *                                         for default DEFAULT_HTTP_CODE_ERROR.
+	 * @param integer|null      $json_opts     See http://php.net/manual/en/function.json-encode.php for supported
+	 *                                         options or pass @null to use value from your config (or defaults).
+	 *
+	 * @return HttpResponse
+	 */
+	public static function error(int $api_code, array $placeholders = null, $data = null, int $http_code = null,
+								 int $encoding_options = null): HttpResponse
+	{
+		return static::buildErrorResponse($data, $api_code, $http_code, $placeholders, $encoding_options);
+	}
+
+	/**
+	 * @param integer           $api_code      Your API code to be returned with the response object.
+	 * @param object|array|null $data          Array of primitives and supported objects to be returned in 'data' node
+	 *                                         of the JSON response, single supported object or @null if there's no
+	 *                                         to be returned.
+	 * @param array|null        $placeholders  Placeholders passed to Lang::get() for message placeholders
+	 *                                         substitution or @null if none.
+	 * @param integer|null      $json_opts     See http://php.net/manual/en/function.json-encode.php for supported
+	 *                                         options or pass @null to use value from your config (or defaults).
+	 *
+	 * @return HttpResponse
+	 */
+	public static function errorWithData(int $api_code, $data, array $placeholders = null,
+										 int $json_opts = null): HttpResponse
+	{
+		return static::buildErrorResponse($data, $api_code, null, $placeholders, $json_opts);
+	}
+
+	/**
+	 * @param integer           $api_code      Your API code to be returned with the response object.
+	 * @param object|array|null $data          Array of primitives and supported objects to be returned in 'data' node
+	 *                                         of the JSON response, single supported object or @null if there's no
+	 *                                         to be returned.
+	 * @param integer           $http_code     HTTP code to be used for HttpResponse sent.
+	 * @param array|null        $placeholders  Placeholders passed to Lang::get() for message placeholders
+	 *                                         substitution or @null if none.
+	 * @param integer|null      $json_opts     See http://php.net/manual/en/function.json-encode.php for supported
+	 *                                         options or pass @null to use value from your config (or defaults).
+	 *
+	 * @return HttpResponse
+	 *
+	 * @throws \InvalidArgumentException if http_code is @null
+	 */
+	public static function errorWithDataAndHttpCode(int $api_code, $data, int $http_code, array $placeholders = null,
+													int $json_opts = null): HttpResponse
+	{
+		return static::buildErrorResponse($data, $api_code, $http_code, $placeholders, $json_opts);
+	}
+
+	/**
+	 * @param integer    $api_code     Your API code to be returned with the response object.
+	 * @param integer    $http_code    HTTP code to be used for HttpResponse sent or @null
+	 *                                 for default DEFAULT_HTTP_CODE_ERROR.
+	 * @param array|null $placeholders Placeholders passed to Lang::get() for message placeholders
+	 *                                 substitution or @null if none.
+	 *
+	 * @return HttpResponse
+	 *
+	 * @throws \InvalidArgumentException if http_code is @null
+	 */
+	public static function errorWithHttpCode(int $api_code, int $http_code, array $placeholders = null): HttpResponse
+	{
+		return static::buildErrorResponse(null, $api_code, $http_code, $placeholders);
+	}
+
+	/**
+	 * @param integer           $api_code  Your API code to be returned with the response object.
+	 * @param string            $message   Custom message to be returned as part of error response
+	 * @param object|array|null $data      Array of primitives and supported objects to be returned in 'data' node
+	 *                                     of the JSON response, single supported object or @null if there's no
+	 *                                     to be returned.
+	 * @param integer|null      $http_code Optional HTTP status code to be used for HttpResponse sent
+	 *                                     or @null for DEFAULT_HTTP_CODE_ERROR
+	 * @param integer|null      $json_opts See http://php.net/manual/en/function.json-encode.php for supported
+	 *                                     options or pass @null to use value from your config (or defaults).
+	 *
+	 * @return HttpResponse
+	 */
+	public static function errorWithMessageAndData(int $api_code, string $message, $data,
+												   int $http_code = null, int $json_opts = null): HttpResponse
+	{
+		return static::buildErrorResponse($data, $api_code, $http_code, null,
+			$message, null, $json_opts);
+	}
+
+	/**
+	 * @param integer           $api_code   Your API code to be returned with the response object.
+	 * @param string            $message    custom message to be returned as part of error response
+	 * @param object|array|null $data       Array of primitives and supported objects to be returned in 'data' node
+	 *                                      of the JSON response, single supported object or @null if there's no
+	 *                                      to be returned.
+	 * @param integer|null      $http_code  HTTP code to be used for HttpResponse sent or @null
+	 *                                      for default DEFAULT_HTTP_CODE_ERROR.
+	 * @param integer|null      $json_opts  See http://php.net/manual/en/function.json-encode.php for supported
+	 *                                      options or pass @null to use value from your config (or defaults).
+	 * @param array|null        $debug_data optional debug data array to be added to returned JSON.
+	 *
+	 * @return HttpResponse
+	 */
+	public static function errorWithMessageAndDataAndDebug(int $api_code, string $message, $data,
+														   int $http_code = null, int $json_opts = null,
+														   array $debug_data = null): HttpResponse
+	{
+		return static::buildErrorResponse($data, $api_code, $http_code, null,
+			$message, null, $json_opts, $debug_data);
+	}
+
+	/**
+	 * @param integer      $api_code  Your API code to be returned with the response object.
+	 * @param string       $message   Custom message to be returned as part of error response
+	 * @param integer|null $http_code HTTP code to be used with final response sent or @null
+	 *                                for default DEFAULT_HTTP_CODE_ERROR.
+	 *
+	 * @return HttpResponse
+	 */
+	public static function errorWithMessage(int $api_code, string $message, int $http_code = null): HttpResponse
+	{
+		return static::buildErrorResponse(null, $api_code, $http_code, null, $message);
+	}
+
+	/**
+	 * Builds error Response object. Supports optional arguments passed to Lang::get() if associated error message
+	 * uses placeholders as well as return data payload
+	 *
+	 * @param object|array|null $data          Array of primitives and supported objects to be returned in 'data' node
+	 *                                         of the JSON response, single supported object or @null if there's no
+	 *                                         to be returned.
+	 * @param integer           $api_code      Your API code to be returned with the response object.
+	 * @param integer|null      $http_code     HTTP code to be used for HttpResponse sent or @null
+	 *                                         for default DEFAULT_HTTP_CODE_ERROR.
+	 * @param array|null        $placeholders  Placeholders passed to Lang::get() for message placeholders
+	 *                                         substitution or @null if none.
+	 * @param string|null       $message       custom message to be returned as part of error response
+	 * @param array|null        $headers       optional HTTP headers to be returned in error response
+	 * @param integer|null      $json_opts     See http://php.net/manual/en/function.json-encode.php for supported
+	 *                                         options or pass @null to use value from your config (or defaults).
+	 * @param array|null        $debug_data    optional debug data array to be added to returned JSON.
+	 *
+	 * @return HttpResponse
+	 *
+	 * @throws \InvalidArgumentException Thrown if $code is not correct, outside the range, equals OK code etc.
+	 *
+	 * @noinspection MoreThanThreeArgumentsInspection
+	 */
+	protected static function buildErrorResponse($data, int $api_code, int $http_code = null,
+												 array $placeholders = null,
+												 string $message = null, array $headers = null,
+												 int $json_opts = null,
+												 array $debug_data = null): HttpResponse
+	{
+		$http_code = $http_code ?? static::DEFAULT_HTTP_CODE_ERROR;
+		$headers = $headers ?? [];
+
+		Validator::assertInt('api_code', $api_code);
+
+		$code_ok = BaseApiCodes::OK();
+		if ($api_code !== $code_ok) {
+			Validator::assertIntRange('api_code', $api_code, BaseApiCodes::getMinCode(), BaseApiCodes::getMaxCode());
+		}
+		if ($api_code === $code_ok) {
+			throw new \InvalidArgumentException(
+				"Error response cannot use api_code of value  {$code_ok} which is reserved for OK");
+		}
+
+		Validator::assertInt('http_code', $http_code);
+		Validator::assertIntRange('http_code', $http_code, static::ERROR_HTTP_CODE_MIN, static::ERROR_HTTP_CODE_MAX);
+
+		$msg_or_api_code = $message ?? $api_code;
+
+		return static::make(false, $api_code, $msg_or_api_code, $data, $http_code,
+			$placeholders, $headers, $json_opts, $debug_data);
+	}
+
+	/**
+	 * @param boolean           $success         @true if response reports successful operation, @false otherwise.
+	 * @param integer           $api_code        Your API code to be returned with the response object.
+	 * @param string|integer    $msg_or_api_code message string or valid API code to get message for
+	 * @param object|array|null $data            optional additional data to be included in response object
+	 * @param integer|null      $http_code       HTTP code for the HttpResponse or @null for either DEFAULT_HTTP_CODE_OK
+	 *                                           or DEFAULT_HTTP_CODE_ERROR depending on the $success.
+	 * @param array|null        $placeholders    Placeholders passed to Lang::get() for message placeholders
+	 *                                           substitution or @null if none.
+	 * @param array|null        $headers         Optional HTTP headers to be returned in the response.
+	 * @param integer|null      $json_opts       See http://php.net/manual/en/function.json-encode.php for supported
+	 *                                           options or pass @null to use value from your config (or defaults).
+	 * @param array|null        $debug_data      Optional debug data array to be added to returned JSON.
+	 *
+	 * @return HttpResponse
+	 *
+	 * @throws \InvalidArgumentException If $api_code is neither a string nor valid integer code.
+	 * @throws \InvalidArgumentException if $data is an object of class that is not configured in "classes" mapping.
+	 *
+	 * @noinspection MoreThanThreeArgumentsInspection
+	 */
+	protected static function make(bool $success, int $api_code, $msg_or_api_code, $data = null,
+								   int $http_code = null, array $placeholders = null, array $headers = null,
+								   int $json_opts = null, array $debug_data = null): HttpResponse
+	{
+		$headers = $headers ?? [];
+		$http_code = $http_code ?? ($success ? static::DEFAULT_HTTP_CODE_OK : static::DEFAULT_HTTP_CODE_ERROR);
+		$json_opts = $json_opts ?? Config::get(self::CONF_KEY_ENCODING_OPTIONS, static::DEFAULT_ENCODING_OPTIONS);
+
+		Validator::assertInt('encoding_options', $json_opts);
+
+		Validator::assertInt('api_code', $api_code);
+		if (!BaseApiCodes::isCodeValid($api_code)) {
+			$min = BaseApiCodes::getMinCode();
+			$max = BaseApiCodes::getMaxCode();
+			throw new \InvalidArgumentException("API code value ({$api_code}) is out of allowed range {$min}-{$max}");
+		}
+
+		return Response::json(
+			static::buildResponse($success, $api_code, $msg_or_api_code, $placeholders, $data, $debug_data),
+			$http_code, $headers, $json_opts);
+	}
+
+	/**
+	 * If $msg_or_api_code is integer value, returns human readable message associated with that code (with
+	 * fallback to built-in default string if no api code mapping is set. If $msg_or_api_code is a string,
+	 * returns it unaltered.
+	 *
+	 * @param boolean    $success      @true if response reports successful operation, @false otherwise.
+	 * @param integer    $api_code     Your API code to be returned with the response object.
+	 * @param array|null $placeholders Placeholders passed to Lang::get() for message placeholders
+	 *                                 substitution or @null if none.
+	 *
+	 * @return string
+	 */
+	protected static function getMessageForApiCode(bool $success, int $api_code, array $placeholders = null): string
+	{
+		// We got integer value here not a message string, so we need to check if we have the mapping for
+		// this string already configured.
+		$key = BaseApiCodes::getCodeMessageKey($api_code);
+		if ($key === null) {
+			// nope, let's get the default one instead, based of
+			$fallback_code = $success ? BaseApiCodes::OK() : BaseApiCodes::NO_ERROR_MESSAGE();
+			$key = BaseApiCodes::getCodeMessageKey($fallback_code);
+		}
+
+		$placeholders = $placeholders ?? [];
+		if (!array_key_exists('api_code', $placeholders)) {
+			$placeholders['api_code'] = $api_code;
+		}
+
+		return \Lang::get($key, $placeholders);
+	}
+
+	/**
+	 * Creates standardised API response array. This is final method called in the whole pipeline before we
+	 * return final JSON back to client. If you want to manipulate your response, this is the place to do that.
+	 * If you set APP_DEBUG to true, 'code_hex' field will be additionally added to reported JSON for easier
+	 * manual debugging.
+	 *
+	 * @param boolean           $success         @true if response reports successful operation, @false otherwise.
+	 * @param integer           $api_code        Your API code to be returned with the response object.
+	 * @param string|integer    $msg_or_api_code Message string or valid API code to get message for.
+	 * @param array|null        $placeholders    Placeholders passed to Lang::get() for message placeholders
+	 *                                           substitution or @null if none.
+	 * @param object|array|null $data            API response data if any
+	 * @param array|null        $debug_data      optional debug data array to be added to returned JSON.
+	 *
+	 * @return array response ready to be encoded as json and sent back to client
+	 *
+	 * @throws \RuntimeException in case of missing or invalid "classes" mapping configuration
+	 */
+	protected static function buildResponse(bool $success, int $api_code,
+											$msg_or_api_code, array $placeholders = null,
+											$data = null, array $debug_data = null): array
+	{
+		// ensure $data is either @null, array or object of class with configured mapping.
+		$converter = new Converter();
+
+		$data = $converter->convert($data);
+		if ($data !== null && !is_object($data)) {
+			// ensure we get object in final JSON structure in data node
+			$data = (object)$data;
+		}
+
+		// get human readable message for API code or use message string (if given instead of API code)
+		if (is_int($msg_or_api_code)) {
+			$message = self::getMessageForApiCode($success, $msg_or_api_code, $placeholders);
+		} else {
+			Validator::assertString('message', $msg_or_api_code);
+			$message = $msg_or_api_code;
+		}
+
+		/** @noinspection PhpUndefinedClassInspection */
+		$response = [
+			static::KEY_SUCCESS => $success,
+			static::KEY_CODE    => $api_code,
+			static::KEY_LOCALE  => \App::getLocale(),
+			static::KEY_MESSAGE => $message,
+			static::KEY_DATA    => $data,
+		];
+
+		if ($debug_data !== null) {
+			$debug_key = Config::get(static::CONF_KEY_DEBUG_DEBUG_KEY, self::KEY_DEBUG);
+			$response[ $debug_key ] = $debug_data;
+		}
+
+		return $response;
+	}
 
 }

Spacing +2 added lines, -2 removed lines

@@ -505,7 +505,7 @@ 
         $data = $converter->convert($data);
         if ($data !== null && !is_object($data)) {
             // ensure we get object in final JSON structure in data node
-            $data = (object)$data;
+            $data = (object) $data;
         }
 
         // get human readable message for API code or use message string (if given instead of API code)
@@ -527,7 +527,7 @@ 
 
         if ($debug_data !== null) {
             $debug_key = Config::get(static::CONF_KEY_DEBUG_DEBUG_KEY, self::KEY_DEBUG);
-            $response[ $debug_key ] = $debug_data;
+            $response[$debug_key] = $debug_data;
         }
 
         return $response;

src/ApiCodesHelpers.php

Spacing +1 added lines, -1 removed lines

@@ -112,7 +112,7 @@
 
         $map = static::getMap();
 
-        return $map[ $api_code ] ?? null;
+        return $map[$api_code] ?? null;
     }
 
     /**

Indentation +123 added lines, -123 removed lines

@@ -21,128 +21,128 @@
  */
 trait ApiCodesHelpers
 {
-    /**
-     * Returns lowest allowed error code for this module
-     *
-     * @return integer
-     *
-     * @throws \RuntimeException Throws exception if no min_code set up
-     */
-    public static function getMinCode(): int
-    {
-        $key = ResponseBuilder::CONF_KEY_MIN_CODE;
-        $min_code = Config::get($key, null);
-
-        if ($min_code === null) {
-            throw new \RuntimeException(sprintf('CONFIG: Missing "%s" key', $key));
-        }
-
-        return $min_code;
-    }
-
-    /**
-     * Returns highest allowed error code for this module
-     *
-     * @return integer
-     *
-     * @throws \RuntimeException Throws exception if no max_code set up
-     */
-    public static function getMaxCode(): int
-    {
-        $key = ResponseBuilder::CONF_KEY_MAX_CODE;
-        $max_code = Config::get($key, null);
-
-        if ($max_code === null) {
-            throw new \RuntimeException(sprintf('CONFIG: Missing "%s" key', $key));
-        }
-
-        return $max_code;
-    }
-
-    /**
-     * Returns array of error code constants defined in this class. Used mainly for debugging/tests
-     *
-     * @return array
-     * @throws \ReflectionException
-     */
-    public static function getApiCodeConstants(): array
-    {
-        /** @noinspection PhpUnhandledExceptionInspection */
-        return (new \ReflectionClass(static::class))->getConstants();
-    }
-
-    /**
-     * Returns complete error code to locale string mapping array
-     *
-     * @return array
-     *
-     * @throws \RuntimeException Thrown when builder map is not configured.
-     */
-    public static function getMap(): array
-    {
-        $user_map = Config::get(ResponseBuilder::CONF_KEY_MAP, null);
-        if ($user_map === null) {
-            throw new \RuntimeException(sprintf('CONFIG: Missing "%s" key', ResponseBuilder::CONF_KEY_MAP));
-        }
-        if (!is_array($user_map)) {
-            throw new \RuntimeException(sprintf('CONFIG: "%s" must be an array', ResponseBuilder::CONF_KEY_MAP));
-        }
-        return Util::mergeConfig(BaseApiCodes::getBaseMap(), $user_map);
-    }
-
-    /**
-     * Returns locale mappings key for given api code or @null if there's no mapping
-     *
-     * @param integer $api_code Api code to look for mapped message for.
-     *
-     * @return string|null
-     *
-     * @throws \InvalidArgumentException If $code is not in allowed range.
-     */
-    public static function getCodeMessageKey(int $api_code): ?string
-    {
-        if (!static::isCodeValid($api_code)) {
-            $min = static::getMinCode();
-            $max = static::getMaxCode();
-            throw new \InvalidArgumentException("API code value ({$api_code}) is out of allowed range {$min}-{$max}");
-        }
-
-        $map = static::getMap();
-
-        return $map[ $api_code ] ?? null;
-    }
-
-    /**
-     * Checks if given API $code can be used in current configuration.
-     *
-     * @param int $code API code to validate
-     *
-     * @return bool
-     */
-    public static function isCodeValid(int $code): bool
-    {
-        return ($code === 0) || (($code >= static::getMinCode()) && ($code <= static::getMaxCode()));
-    }
-
-    /**
-     * Returns final API code for internal code, remapped to configured code range
-     *
-     * @param int $internal_code
-     *
-     * @return int
-     *
-     * @throws \InvalidArgumentException
-     */
-    protected static function getCodeForInternalOffset(int $internal_code): int
-    {
-        $min = static::RESERVED_MIN_API_CODE_OFFSET;
-        $max = static::RESERVED_MAX_API_CODE_OFFSET;
-        if (($internal_code < $min) || ($internal_code > $max)) {
-            throw new \InvalidArgumentException(
-                "Invalid internal code ({$internal_code}). Must be between {$min}-{$max} inclusive.");
-        }
-
-        return ($internal_code === 0) ? 0 : $internal_code + static::getMinCode();
-    }
+	/**
+	 * Returns lowest allowed error code for this module
+	 *
+	 * @return integer
+	 *
+	 * @throws \RuntimeException Throws exception if no min_code set up
+	 */
+	public static function getMinCode(): int
+	{
+		$key = ResponseBuilder::CONF_KEY_MIN_CODE;
+		$min_code = Config::get($key, null);
+
+		if ($min_code === null) {
+			throw new \RuntimeException(sprintf('CONFIG: Missing "%s" key', $key));
+		}
+
+		return $min_code;
+	}
+
+	/**
+	 * Returns highest allowed error code for this module
+	 *
+	 * @return integer
+	 *
+	 * @throws \RuntimeException Throws exception if no max_code set up
+	 */
+	public static function getMaxCode(): int
+	{
+		$key = ResponseBuilder::CONF_KEY_MAX_CODE;
+		$max_code = Config::get($key, null);
+
+		if ($max_code === null) {
+			throw new \RuntimeException(sprintf('CONFIG: Missing "%s" key', $key));
+		}
+
+		return $max_code;
+	}
+
+	/**
+	 * Returns array of error code constants defined in this class. Used mainly for debugging/tests
+	 *
+	 * @return array
+	 * @throws \ReflectionException
+	 */
+	public static function getApiCodeConstants(): array
+	{
+		/** @noinspection PhpUnhandledExceptionInspection */
+		return (new \ReflectionClass(static::class))->getConstants();
+	}
+
+	/**
+	 * Returns complete error code to locale string mapping array
+	 *
+	 * @return array
+	 *
+	 * @throws \RuntimeException Thrown when builder map is not configured.
+	 */
+	public static function getMap(): array
+	{
+		$user_map = Config::get(ResponseBuilder::CONF_KEY_MAP, null);
+		if ($user_map === null) {
+			throw new \RuntimeException(sprintf('CONFIG: Missing "%s" key', ResponseBuilder::CONF_KEY_MAP));
+		}
+		if (!is_array($user_map)) {
+			throw new \RuntimeException(sprintf('CONFIG: "%s" must be an array', ResponseBuilder::CONF_KEY_MAP));
+		}
+		return Util::mergeConfig(BaseApiCodes::getBaseMap(), $user_map);
+	}
+
+	/**
+	 * Returns locale mappings key for given api code or @null if there's no mapping
+	 *
+	 * @param integer $api_code Api code to look for mapped message for.
+	 *
+	 * @return string|null
+	 *
+	 * @throws \InvalidArgumentException If $code is not in allowed range.
+	 */
+	public static function getCodeMessageKey(int $api_code): ?string
+	{
+		if (!static::isCodeValid($api_code)) {
+			$min = static::getMinCode();
+			$max = static::getMaxCode();
+			throw new \InvalidArgumentException("API code value ({$api_code}) is out of allowed range {$min}-{$max}");
+		}
+
+		$map = static::getMap();
+
+		return $map[ $api_code ] ?? null;
+	}
+
+	/**
+	 * Checks if given API $code can be used in current configuration.
+	 *
+	 * @param int $code API code to validate
+	 *
+	 * @return bool
+	 */
+	public static function isCodeValid(int $code): bool
+	{
+		return ($code === 0) || (($code >= static::getMinCode()) && ($code <= static::getMaxCode()));
+	}
+
+	/**
+	 * Returns final API code for internal code, remapped to configured code range
+	 *
+	 * @param int $internal_code
+	 *
+	 * @return int
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	protected static function getCodeForInternalOffset(int $internal_code): int
+	{
+		$min = static::RESERVED_MIN_API_CODE_OFFSET;
+		$max = static::RESERVED_MAX_API_CODE_OFFSET;
+		if (($internal_code < $min) || ($internal_code > $max)) {
+			throw new \InvalidArgumentException(
+				"Invalid internal code ({$internal_code}). Must be between {$min}-{$max} inclusive.");
+		}
+
+		return ($internal_code === 0) ? 0 : $internal_code + static::getMinCode();
+	}
 
 }

src/Converter.php

Indentation +140 added lines, -140 removed lines

@@ -22,144 +22,144 @@
  */
 class Converter
 {
-    /**
-     * @var array
-     */
-    protected $classes = [];
-
-    /**
-     * Converter constructor.
-     *
-     * @throws \RuntimeException
-     */
-    public function __construct()
-    {
-        $classes = Config::get(ResponseBuilder::CONF_KEY_CLASSES) ?? [];
-        if (!is_array($classes)) {
-            throw new \RuntimeException(
-                sprintf('CONFIG: "classes" mapping must be an array (%s given)', gettype($classes)));
-        }
-
-        $this->classes = $classes;
-    }
-
-    /**
-     * Returns local copy of configuration mapping for the classes.
-     *
-     * @return array
-     */
-    public function getClasses(): array
-    {
-        return $this->classes;
-    }
-
-    /**
-     * Checks if we have "classes" mapping configured for $data object class.
-     * Returns @true if there's valid config for this class.
-     * Throws \RuntimeException if there's no config "classes" mapping entry for this object configured.
-     * Throws \InvalidArgumentException if No data conversion mapping configured for given class.
-     *
-     * @param object $data Object to check mapping for.
-     *
-     * @return array
-     *
-     * @throws \InvalidArgumentException
-     */
-    protected function getClassMappingConfigOrThrow(object $data): array
-    {
-        $result = null;
-
-        // check for exact class name match...
-        $cls = get_class($data);
-        if (array_key_exists($cls, $this->classes)) {
-            $result = $this->classes[ $cls ];
-        } else {
-            // no exact match, then lets try with `instanceof`
-            foreach (array_keys($this->classes) as $class_name) {
-                if ($data instanceof $class_name) {
-                    $result = $this->classes[ $class_name ];
-                    break;
-                }
-            }
-        }
-
-        if ($result === null) {
-            throw new \InvalidArgumentException(sprintf('No data conversion mapping configured for "%s" class.', $cls));
-        }
-
-        return $result;
-    }
-
-    /**
-     * We need to prepare source data
-     *
-     * @param object|array|null $data
-     *
-     * @return array|null
-     *
-     * @throws \InvalidArgumentException
-     */
-    public function convert($data = null): ?array
-    {
-        if ($data === null) {
-            return null;
-        }
-
-        if (is_object($data)) {
-            $cfg = $this->getClassMappingConfigOrThrow($data);
-            $data = [$cfg[ ResponseBuilder::KEY_KEY ] => $data->{$cfg[ ResponseBuilder::KEY_METHOD ]}()];
-        } elseif (!is_array($data)) {
-            throw new \InvalidArgumentException(
-                sprintf('Payload must be null, array or object with mapping ("%s" given).', gettype($data)));
-        }
-
-        return $this->convertArray($data);
-    }
-
-    /**
-     * Recursively walks $data array and converts all known objects if found. Note
-     * $data array is passed by reference so source $data array may be modified.
-     *
-     * @param array $data array to recursively convert known elements of
-     *
-     * @return array
-     *
-     * @throws \RuntimeException
-     */
-    protected function convertArray(array $data): array
-    {
-        // This is to ensure that we either have array with user provided keys i.e. ['foo'=>'bar'], which will then
-        // be turned into JSON object or array without user specified keys (['bar']) which we would return as JSON
-        // array. But you can't mix these two as the final JSON would not produce predictable results.
-        $string_keys_cnt = 0;
-        $int_keys_cnt = 0;
-        foreach ($data as $key => $val) {
-            if (is_int($key)) {
-                $int_keys_cnt++;
-            } else {
-                $string_keys_cnt++;
-            }
-
-            if (($string_keys_cnt > 0) && ($int_keys_cnt > 0)) {
-                throw new \RuntimeException(
-                    'Invalid data array. Either set own keys for all the items or do not specify any keys at all. ' .
-                    'Arrays with mixed keys are not supported by design.');
-            }
-        }
-
-        foreach ($data as $key => $val) {
-            if (is_array($val)) {
-                $data[ $key ] = $this->convertArray($val);
-            } elseif (is_object($val)) {
-                $cls = get_class($val);
-                if (array_key_exists($cls, $this->classes)) {
-                    $conversion_method = $this->classes[ $cls ][ ResponseBuilder::KEY_METHOD ];
-                    $converted_data = $val->$conversion_method();
-                    $data[ $key ] = $converted_data;
-                }
-            }
-        }
-
-        return $data;
-    }
+	/**
+	 * @var array
+	 */
+	protected $classes = [];
+
+	/**
+	 * Converter constructor.
+	 *
+	 * @throws \RuntimeException
+	 */
+	public function __construct()
+	{
+		$classes = Config::get(ResponseBuilder::CONF_KEY_CLASSES) ?? [];
+		if (!is_array($classes)) {
+			throw new \RuntimeException(
+				sprintf('CONFIG: "classes" mapping must be an array (%s given)', gettype($classes)));
+		}
+
+		$this->classes = $classes;
+	}
+
+	/**
+	 * Returns local copy of configuration mapping for the classes.
+	 *
+	 * @return array
+	 */
+	public function getClasses(): array
+	{
+		return $this->classes;
+	}
+
+	/**
+	 * Checks if we have "classes" mapping configured for $data object class.
+	 * Returns @true if there's valid config for this class.
+	 * Throws \RuntimeException if there's no config "classes" mapping entry for this object configured.
+	 * Throws \InvalidArgumentException if No data conversion mapping configured for given class.
+	 *
+	 * @param object $data Object to check mapping for.
+	 *
+	 * @return array
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	protected function getClassMappingConfigOrThrow(object $data): array
+	{
+		$result = null;
+
+		// check for exact class name match...
+		$cls = get_class($data);
+		if (array_key_exists($cls, $this->classes)) {
+			$result = $this->classes[ $cls ];
+		} else {
+			// no exact match, then lets try with `instanceof`
+			foreach (array_keys($this->classes) as $class_name) {
+				if ($data instanceof $class_name) {
+					$result = $this->classes[ $class_name ];
+					break;
+				}
+			}
+		}
+
+		if ($result === null) {
+			throw new \InvalidArgumentException(sprintf('No data conversion mapping configured for "%s" class.', $cls));
+		}
+
+		return $result;
+	}
+
+	/**
+	 * We need to prepare source data
+	 *
+	 * @param object|array|null $data
+	 *
+	 * @return array|null
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	public function convert($data = null): ?array
+	{
+		if ($data === null) {
+			return null;
+		}
+
+		if (is_object($data)) {
+			$cfg = $this->getClassMappingConfigOrThrow($data);
+			$data = [$cfg[ ResponseBuilder::KEY_KEY ] => $data->{$cfg[ ResponseBuilder::KEY_METHOD ]}()];
+		} elseif (!is_array($data)) {
+			throw new \InvalidArgumentException(
+				sprintf('Payload must be null, array or object with mapping ("%s" given).', gettype($data)));
+		}
+
+		return $this->convertArray($data);
+	}
+
+	/**
+	 * Recursively walks $data array and converts all known objects if found. Note
+	 * $data array is passed by reference so source $data array may be modified.
+	 *
+	 * @param array $data array to recursively convert known elements of
+	 *
+	 * @return array
+	 *
+	 * @throws \RuntimeException
+	 */
+	protected function convertArray(array $data): array
+	{
+		// This is to ensure that we either have array with user provided keys i.e. ['foo'=>'bar'], which will then
+		// be turned into JSON object or array without user specified keys (['bar']) which we would return as JSON
+		// array. But you can't mix these two as the final JSON would not produce predictable results.
+		$string_keys_cnt = 0;
+		$int_keys_cnt = 0;
+		foreach ($data as $key => $val) {
+			if (is_int($key)) {
+				$int_keys_cnt++;
+			} else {
+				$string_keys_cnt++;
+			}
+
+			if (($string_keys_cnt > 0) && ($int_keys_cnt > 0)) {
+				throw new \RuntimeException(
+					'Invalid data array. Either set own keys for all the items or do not specify any keys at all. ' .
+					'Arrays with mixed keys are not supported by design.');
+			}
+		}
+
+		foreach ($data as $key => $val) {
+			if (is_array($val)) {
+				$data[ $key ] = $this->convertArray($val);
+			} elseif (is_object($val)) {
+				$cls = get_class($val);
+				if (array_key_exists($cls, $this->classes)) {
+					$conversion_method = $this->classes[ $cls ][ ResponseBuilder::KEY_METHOD ];
+					$converted_data = $val->$conversion_method();
+					$data[ $key ] = $converted_data;
+				}
+			}
+		}
+
+		return $data;
+	}
 }

Spacing +6 added lines, -6 removed lines

@@ -72,12 +72,12 @@ 
         // check for exact class name match...
         $cls = get_class($data);
         if (array_key_exists($cls, $this->classes)) {
-            $result = $this->classes[ $cls ];
+            $result = $this->classes[$cls];
         } else {
             // no exact match, then lets try with `instanceof`
             foreach (array_keys($this->classes) as $class_name) {
                 if ($data instanceof $class_name) {
-                    $result = $this->classes[ $class_name ];
+                    $result = $this->classes[$class_name];
                     break;
                 }
             }
@@ -107,7 +107,7 @@ 
 
         if (is_object($data)) {
             $cfg = $this->getClassMappingConfigOrThrow($data);
-            $data = [$cfg[ ResponseBuilder::KEY_KEY ] => $data->{$cfg[ ResponseBuilder::KEY_METHOD ]}()];
+            $data = [$cfg[ResponseBuilder::KEY_KEY] => $data->{$cfg[ResponseBuilder::KEY_METHOD]}()];
         } elseif (!is_array($data)) {
             throw new \InvalidArgumentException(
                 sprintf('Payload must be null, array or object with mapping ("%s" given).', gettype($data)));
@@ -149,13 +149,13 @@ 
 
         foreach ($data as $key => $val) {
             if (is_array($val)) {
-                $data[ $key ] = $this->convertArray($val);
+                $data[$key] = $this->convertArray($val);
             } elseif (is_object($val)) {
                 $cls = get_class($val);
                 if (array_key_exists($cls, $this->classes)) {
-                    $conversion_method = $this->classes[ $cls ][ ResponseBuilder::KEY_METHOD ];
+                    $conversion_method = $this->classes[$cls][ResponseBuilder::KEY_METHOD];
                     $converted_data = $val->$conversion_method();
-                    $data[ $key ] = $converted_data;
+                    $data[$key] = $converted_data;
                 }
             }
         }

src/Validator.php

Indentation +76 added lines, -76 removed lines

@@ -15,88 +15,88 @@
  */
 class Validator
 {
-    /** @var string */
-    public const TYPE_STRING = 'string';
+	/** @var string */
+	public const TYPE_STRING = 'string';
 
-    /** @var string */
-    public const TYPE_INTEGER = 'integer';
+	/** @var string */
+	public const TYPE_INTEGER = 'integer';
 
-    /** @var string */
-    public const TYPE_BOOL = 'boolean';
+	/** @var string */
+	public const TYPE_BOOL = 'boolean';
 
-    /**
-     * Checks if given $val is of type integer
-     *
-     * @param string $key Name of the key to be used if exception is thrown.
-     * @param mixed  $var Variable to be asserted.
-     *
-     * @return void
-     *
-     * @throws \InvalidArgumentException
-     */
-    public static function assertInt(string $key, $var): void
-    {
-        self::assertType($key, $var, [self::TYPE_INTEGER]);
-    }
+	/**
+	 * Checks if given $val is of type integer
+	 *
+	 * @param string $key Name of the key to be used if exception is thrown.
+	 * @param mixed  $var Variable to be asserted.
+	 *
+	 * @return void
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	public static function assertInt(string $key, $var): void
+	{
+		self::assertType($key, $var, [self::TYPE_INTEGER]);
+	}
 
-    /**
-     * Checks if given $val is of type string
-     *
-     * @param string $name Label or name of the variable to be used in exception message (if thrown).
-     * @param mixed  $var  Variable to be asserted.
-     *
-     * @return void
-     *
-     * @throws \InvalidArgumentException
-     */
-    public static function assertString(string $name, $var): void
-    {
-        self::assertType($name, $var, [self::TYPE_STRING]);
-    }
+	/**
+	 * Checks if given $val is of type string
+	 *
+	 * @param string $name Label or name of the variable to be used in exception message (if thrown).
+	 * @param mixed  $var  Variable to be asserted.
+	 *
+	 * @return void
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	public static function assertString(string $name, $var): void
+	{
+		self::assertType($name, $var, [self::TYPE_STRING]);
+	}
 
-    /**
-     * @param string $name Label or name of the variable to be used in exception message (if thrown).
-     * @param mixed  $var  Variable to be asserted.
-     * @param int    $min  Min allowed value (inclusive)
-     * @param int    $max  Max allowed value (inclusive)
-     *
-     * @return void
-     *
-     * @throws \InvalidArgumentException
-     * @throws \RuntimeException
-     */
-    public static function assertIntRange(string $name, $var, int $min, int $max): void
-    {
-        self::assertInt($name, $var);
+	/**
+	 * @param string $name Label or name of the variable to be used in exception message (if thrown).
+	 * @param mixed  $var  Variable to be asserted.
+	 * @param int    $min  Min allowed value (inclusive)
+	 * @param int    $max  Max allowed value (inclusive)
+	 *
+	 * @return void
+	 *
+	 * @throws \InvalidArgumentException
+	 * @throws \RuntimeException
+	 */
+	public static function assertIntRange(string $name, $var, int $min, int $max): void
+	{
+		self::assertInt($name, $var);
 
-        if ($min > $max) {
-            throw new \RuntimeException(
-                sprintf('%s: Invalid range for "%s". Ensure bound values are not swapped.', __FUNCTION__, $name));
-        }
+		if ($min > $max) {
+			throw new \RuntimeException(
+				sprintf('%s: Invalid range for "%s". Ensure bound values are not swapped.', __FUNCTION__, $name));
+		}
 
-        if (($min > $var) || ($var > $max)) {
-            throw new \InvalidArgumentException(
-                sprintf('Invalid value of "%s" (%d). Must be between %d-%d inclusive.', $name, $var, $min, $max));
-        }
-    }
+		if (($min > $var) || ($var > $max)) {
+			throw new \InvalidArgumentException(
+				sprintf('Invalid value of "%s" (%d). Must be between %d-%d inclusive.', $name, $var, $min, $max));
+		}
+	}
 
-    /**
-     * Checks if $item (of name $key) is of type that is include in $allowed_types.
-     *
-     * @param string $name          Label or name of the variable to be used in exception message (if thrown).
-     * @param mixed  $var           Variable to be asserted.
-     * @param array  $allowed_types Array of allowed types for $var, i.e. [Validator::TYPE_INTEGER]
-     *
-     * @return void
-     *
-     * @throws \InvalidArgumentException
-     */
-    public static function assertType(string $name, $var, array $allowed_types): void
-    {
-        $type = gettype($var);
-        if (!in_array($type, $allowed_types)) {
-            $msg = sprintf('"%s" must be one of allowed types: %s (%s given)', $name, implode(', ', $allowed_types), gettype($var));
-            throw new \InvalidArgumentException($msg);
-        }
-    }
+	/**
+	 * Checks if $item (of name $key) is of type that is include in $allowed_types.
+	 *
+	 * @param string $name          Label or name of the variable to be used in exception message (if thrown).
+	 * @param mixed  $var           Variable to be asserted.
+	 * @param array  $allowed_types Array of allowed types for $var, i.e. [Validator::TYPE_INTEGER]
+	 *
+	 * @return void
+	 *
+	 * @throws \InvalidArgumentException
+	 */
+	public static function assertType(string $name, $var, array $allowed_types): void
+	{
+		$type = gettype($var);
+		if (!in_array($type, $allowed_types)) {
+			$msg = sprintf('"%s" must be one of allowed types: %s (%s given)', $name, implode(', ', $allowed_types), gettype($var));
+			throw new \InvalidArgumentException($msg);
+		}
+	}
 }

src/ExceptionHandlerHelper.php

Indentation +176 added lines, -176 removed lines

@@ -27,180 +27,180 @@
  */
 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 = self::getExceptionHandlerConfig();
-
-        if ($ex instanceof HttpException) {
-            // Check if we have any exception configuration for this particular Http status code.
-            $ex_cfg = $cfg[ HttpException::class ][ $ex->getStatusCode() ] ?? null;
-            if ($ex_cfg === null) {
-                $ex_cfg = $cfg[ HttpException::class ]['default'];
-            }
-
-            $api_code = $ex_cfg['api_code'] ?? BaseApiCodes::EX_UNCAUGHT_EXCEPTION();
-            $http_code = $ex_cfg['http_code'] ?? ResponseBuilder::DEFAULT_HTTP_CODE_ERROR;
-            $msg_key = $ex_cfg['msg_key'] ?? null;
-            $result = static::error($ex, $api_code, $http_code, $msg_key);
-        } elseif ($ex instanceof ValidationException) {
-            $http_code = HttpResponse::HTTP_UNPROCESSABLE_ENTITY;
-            $ex_cfg = $cfg[ HttpException::class ][ $http_code ];
-            $api_code = $ex_cfg['api_code'] ?? BaseApiCodes::EX_UNCAUGHT_EXCEPTION();
-            $http_code = $ex_cfg['http_code'] ?? $http_code;
-            $result = static::error($ex, $api_code, $http_code);
-        }
-
-        if ($result === null) {
-            $ex_cfg = $cfg['default'];
-            $result = static::error($ex, $ex_cfg['api_code'], $ex_cfg['http_code']);
-        }
-
-        return $result;
-    }
-
-    /**
-     * 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
-    {
-        $cfg = static::getExceptionHandlerConfig(HttpException::class);
-        $api_code = $cfg[ HttpResponse::HTTP_UNAUTHORIZED ]['api_code'];
-        $http_code = $cfg[ HttpResponse::HTTP_UNAUTHORIZED ]['http_code'];
-
-        return static::error($exception, $api_code, $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 $msg_key = null): 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) {
-            $http_code = ResponseBuilder::DEFAULT_HTTP_CODE_ERROR;
-        }
-
-        // Let's build the error message.
-        $error_message = $ex->getMessage();
-
-        $placeholders = [
-            'api_code' => $api_code,
-            'message'  => ($error_message !== '') ? $error_message : '???',
-        ];
-
-        // Check if we have dedicated HTTP Code message for this type of HttpException and its status code.
-        if (($error_message === '') && ($ex instanceof HttpException)) {
-            $error_message = Lang::get("response-builder::builder.http_{$ex_http_code}", $placeholders);
-        }
-
-        // Still got nothing? Fall back to built-in generic message for this type of exception.
-        if ($error_message === '') {
-            $key = BaseApiCodes::getCodeMessageKey(($ex instanceof HttpException)
-                ? BaseApiCodes::EX_HTTP_EXCEPTION() : BaseApiCodes::NO_ERROR_MESSAGE());
-            $error_message = Lang::get($key, $placeholders);
-        }
-
-        // If we have trace data debugging enabled, let's gather some debug info and add to the response.
-        $trace_data = null;
-        if (Config::get(ResponseBuilder::CONF_KEY_DEBUG_EX_TRACE_ENABLED, false)) {
-            $trace_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::errorWithMessageAndDataAndDebug($api_code, $error_message, $data,
-            $http_code, null, $trace_data);
-    }
-
-    /**
-     * Returns built-in configration array for ExceptionHandlerHelper
-     *
-     * @return array
-     */
-    protected static function getExceptionHandlerBaseConfig(): array
-    {
-        return [
-            HttpException::class => [
-                // used by unauthenticated() to obtain api and http code for the exception
-                HttpResponse::HTTP_UNAUTHORIZED         => [
-                    'api_code'  => BaseApiCodes::EX_AUTHENTICATION_EXCEPTION(),
-                    'http_code' => HttpResponse::HTTP_UNAUTHORIZED,
-                ],
-
-                // Required by ValidationException handler
-                HttpResponse::HTTP_UNPROCESSABLE_ENTITY => [
-                    'api_code'  => BaseApiCodes::EX_VALIDATION_EXCEPTION(),
-                    'http_code' => HttpResponse::HTTP_UNPROCESSABLE_ENTITY,
-                ],
-                // default handler is mandatory
-                'default'                               => [
-                    'api_code'  => BaseApiCodes::EX_HTTP_EXCEPTION(),
-                    'http_code' => HttpResponse::HTTP_BAD_REQUEST,
-                ],
-            ],
-            // default handler is mandatory
-            'default'            => [
-                'api_code'  => BaseApiCodes::EX_UNCAUGHT_EXCEPTION(),
-                'http_code' => HttpResponse::HTTP_INTERNAL_SERVER_ERROR,
-            ],
-        ];
-    }
-
-    /**
-     * Returns configration array for ExceptionHandlerHelper with user config merged with built-in config.
-     *
-     * @param string|null $key optional configuration node key to have only this portion of the
-     *                         config returned (i.e. `http_exception`).
-     *
-     * @return array
-     */
-    protected static function getExceptionHandlerConfig(string $key = null): array
-    {
-        $result = array_merge(Config::get(ResponseBuilder::CONF_EXCEPTION_HANDLER_KEY, []),
-            self::getExceptionHandlerBaseConfig());
-
-        return ($key === null) ? $result : $result[ $key ];
-    }
+	/**
+	 * 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 = self::getExceptionHandlerConfig();
+
+		if ($ex instanceof HttpException) {
+			// Check if we have any exception configuration for this particular Http status code.
+			$ex_cfg = $cfg[ HttpException::class ][ $ex->getStatusCode() ] ?? null;
+			if ($ex_cfg === null) {
+				$ex_cfg = $cfg[ HttpException::class ]['default'];
+			}
+
+			$api_code = $ex_cfg['api_code'] ?? BaseApiCodes::EX_UNCAUGHT_EXCEPTION();
+			$http_code = $ex_cfg['http_code'] ?? ResponseBuilder::DEFAULT_HTTP_CODE_ERROR;
+			$msg_key = $ex_cfg['msg_key'] ?? null;
+			$result = static::error($ex, $api_code, $http_code, $msg_key);
+		} elseif ($ex instanceof ValidationException) {
+			$http_code = HttpResponse::HTTP_UNPROCESSABLE_ENTITY;
+			$ex_cfg = $cfg[ HttpException::class ][ $http_code ];
+			$api_code = $ex_cfg['api_code'] ?? BaseApiCodes::EX_UNCAUGHT_EXCEPTION();
+			$http_code = $ex_cfg['http_code'] ?? $http_code;
+			$result = static::error($ex, $api_code, $http_code);
+		}
+
+		if ($result === null) {
+			$ex_cfg = $cfg['default'];
+			$result = static::error($ex, $ex_cfg['api_code'], $ex_cfg['http_code']);
+		}
+
+		return $result;
+	}
+
+	/**
+	 * 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
+	{
+		$cfg = static::getExceptionHandlerConfig(HttpException::class);
+		$api_code = $cfg[ HttpResponse::HTTP_UNAUTHORIZED ]['api_code'];
+		$http_code = $cfg[ HttpResponse::HTTP_UNAUTHORIZED ]['http_code'];
+
+		return static::error($exception, $api_code, $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 $msg_key = null): 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) {
+			$http_code = ResponseBuilder::DEFAULT_HTTP_CODE_ERROR;
+		}
+
+		// Let's build the error message.
+		$error_message = $ex->getMessage();
+
+		$placeholders = [
+			'api_code' => $api_code,
+			'message'  => ($error_message !== '') ? $error_message : '???',
+		];
+
+		// Check if we have dedicated HTTP Code message for this type of HttpException and its status code.
+		if (($error_message === '') && ($ex instanceof HttpException)) {
+			$error_message = Lang::get("response-builder::builder.http_{$ex_http_code}", $placeholders);
+		}
+
+		// Still got nothing? Fall back to built-in generic message for this type of exception.
+		if ($error_message === '') {
+			$key = BaseApiCodes::getCodeMessageKey(($ex instanceof HttpException)
+				? BaseApiCodes::EX_HTTP_EXCEPTION() : BaseApiCodes::NO_ERROR_MESSAGE());
+			$error_message = Lang::get($key, $placeholders);
+		}
+
+		// If we have trace data debugging enabled, let's gather some debug info and add to the response.
+		$trace_data = null;
+		if (Config::get(ResponseBuilder::CONF_KEY_DEBUG_EX_TRACE_ENABLED, false)) {
+			$trace_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::errorWithMessageAndDataAndDebug($api_code, $error_message, $data,
+			$http_code, null, $trace_data);
+	}
+
+	/**
+	 * Returns built-in configration array for ExceptionHandlerHelper
+	 *
+	 * @return array
+	 */
+	protected static function getExceptionHandlerBaseConfig(): array
+	{
+		return [
+			HttpException::class => [
+				// used by unauthenticated() to obtain api and http code for the exception
+				HttpResponse::HTTP_UNAUTHORIZED         => [
+					'api_code'  => BaseApiCodes::EX_AUTHENTICATION_EXCEPTION(),
+					'http_code' => HttpResponse::HTTP_UNAUTHORIZED,
+				],
+
+				// Required by ValidationException handler
+				HttpResponse::HTTP_UNPROCESSABLE_ENTITY => [
+					'api_code'  => BaseApiCodes::EX_VALIDATION_EXCEPTION(),
+					'http_code' => HttpResponse::HTTP_UNPROCESSABLE_ENTITY,
+				],
+				// default handler is mandatory
+				'default'                               => [
+					'api_code'  => BaseApiCodes::EX_HTTP_EXCEPTION(),
+					'http_code' => HttpResponse::HTTP_BAD_REQUEST,
+				],
+			],
+			// default handler is mandatory
+			'default'            => [
+				'api_code'  => BaseApiCodes::EX_UNCAUGHT_EXCEPTION(),
+				'http_code' => HttpResponse::HTTP_INTERNAL_SERVER_ERROR,
+			],
+		];
+	}
+
+	/**
+	 * Returns configration array for ExceptionHandlerHelper with user config merged with built-in config.
+	 *
+	 * @param string|null $key optional configuration node key to have only this portion of the
+	 *                         config returned (i.e. `http_exception`).
+	 *
+	 * @return array
+	 */
+	protected static function getExceptionHandlerConfig(string $key = null): array
+	{
+		$result = array_merge(Config::get(ResponseBuilder::CONF_EXCEPTION_HANDLER_KEY, []),
+			self::getExceptionHandlerBaseConfig());
+
+		return ($key === null) ? $result : $result[ $key ];
+	}
 }

Spacing +6 added lines, -6 removed lines

@@ -42,9 +42,9 @@ 
 
         if ($ex instanceof HttpException) {
             // Check if we have any exception configuration for this particular Http status code.
-            $ex_cfg = $cfg[ HttpException::class ][ $ex->getStatusCode() ] ?? null;
+            $ex_cfg = $cfg[HttpException::class][$ex->getStatusCode()] ?? null;
             if ($ex_cfg === null) {
-                $ex_cfg = $cfg[ HttpException::class ]['default'];
+                $ex_cfg = $cfg[HttpException::class]['default'];
             }
 
             $api_code = $ex_cfg['api_code'] ?? BaseApiCodes::EX_UNCAUGHT_EXCEPTION();
@@ -53,7 +53,7 @@ 
             $result = static::error($ex, $api_code, $http_code, $msg_key);
         } elseif ($ex instanceof ValidationException) {
             $http_code = HttpResponse::HTTP_UNPROCESSABLE_ENTITY;
-            $ex_cfg = $cfg[ HttpException::class ][ $http_code ];
+            $ex_cfg = $cfg[HttpException::class][$http_code];
             $api_code = $ex_cfg['api_code'] ?? BaseApiCodes::EX_UNCAUGHT_EXCEPTION();
             $http_code = $ex_cfg['http_code'] ?? $http_code;
             $result = static::error($ex, $api_code, $http_code);
@@ -79,8 +79,8 @@ 
                                                                          AuthException $exception): HttpResponse
     {
         $cfg = static::getExceptionHandlerConfig(HttpException::class);
-        $api_code = $cfg[ HttpResponse::HTTP_UNAUTHORIZED ]['api_code'];
-        $http_code = $cfg[ HttpResponse::HTTP_UNAUTHORIZED ]['http_code'];
+        $api_code = $cfg[HttpResponse::HTTP_UNAUTHORIZED]['api_code'];
+        $http_code = $cfg[HttpResponse::HTTP_UNAUTHORIZED]['http_code'];
 
         return static::error($exception, $api_code, $http_code);
     }
@@ -201,6 +201,6 @@ 
         $result = array_merge(Config::get(ResponseBuilder::CONF_EXCEPTION_HANDLER_KEY, []),
             self::getExceptionHandlerBaseConfig());
 
-        return ($key === null) ? $result : $result[ $key ];
+        return ($key === null) ? $result : $result[$key];
     }
 }

src/lang/pl/builder.php

Indentation +48 added lines, -48 removed lines

@@ -10,54 +10,54 @@
  */
 return [
 
-    'ok'                       => 'OK',
-    'no_error_message'         => 'Błąd #:api_code',
+	'ok'                       => 'OK',
+	'no_error_message'         => 'Błąd #:api_code',
 
-    // Used by Exception Handler Helper (when used)
-    'uncaught_exception'       => 'Nieprzechwycony wyjątek: :message',
-    'http_exception'           => 'Wyjątek HTTP: :message',
+	// Used by Exception Handler Helper (when used)
+	'uncaught_exception'       => 'Nieprzechwycony wyjątek: :message',
+	'http_exception'           => 'Wyjątek HTTP: :message',
 
-    // HttpException handler (added in 6.4.0)
-    // Error messages for HttpException caught w/o custom messages
-    // https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
-    'http_400'                 => 'Bad Request',
-    'http_401'                 => 'Unauthorized',
-    'http_402'                 => 'Payment Required',
-    'http_403'                 => 'Forbidden',
-    'http_404'                 => 'Not Found',
-    'http_405'                 => 'Method Not Allowed',
-    'http_406'                 => 'Not Acceptable',
-    'http_407'                 => 'Proxy Authentication Required',
-    'http_408'                 => 'Request Timeout',
-    'http_409'                 => 'Conflict',
-    'http_410'                 => 'Gone',
-    'http_411'                 => 'Length Required',
-    'http_412'                 => 'Precondition Failed',
-    'http_413'                 => 'Payload Too Large',
-    'http_414'                 => 'URI Too Long',
-    'http_415'                 => 'Unsupported Media Type',
-    'http_416'                 => 'Range Not Satisfiable',
-    'http_417'                 => 'Expectation Failed',
-    'http_421'                 => 'Misdirected Request',
-    'http_422'                 => 'Unprocessable Entity',
-    'http_423'                 => 'Locked',
-    'http_424'                 => 'Failed Dependency',
-    'http_425'                 => 'Too Early',
-    'http_426'                 => 'Upgrade Required',
-    'http_428'                 => 'Precondition Required',
-    'http_429'                 => 'Too Many Requests',
-    'http_431'                 => 'Request Header Fields Too Large',
-    'http_451'                 => 'Unavailable For Legal Reasons',
-    'http_500'                 => 'Internal Server Error',
-    'http_501'                 => 'Not Implemented',
-    'http_502'                 => 'Bad Gateway',
-    'http_503'                 => 'Service Unavailable',
-    'http_504'                 => 'Gateway Timeout',
-    'http_505'                 => 'HTTP Version Not Supported',
-    'http_506'                 => 'Variant Also Negotiates',
-    'http_507'                 => 'Insufficient Storage',
-    'http_508'                 => 'Loop Detected',
-    'http_509'                 => 'Unassigned',
-    'http_510'                 => 'Not Extended',
-    'http_511'                 => 'Network Authentication Required',
+	// HttpException handler (added in 6.4.0)
+	// Error messages for HttpException caught w/o custom messages
+	// https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
+	'http_400'                 => 'Bad Request',
+	'http_401'                 => 'Unauthorized',
+	'http_402'                 => 'Payment Required',
+	'http_403'                 => 'Forbidden',
+	'http_404'                 => 'Not Found',
+	'http_405'                 => 'Method Not Allowed',
+	'http_406'                 => 'Not Acceptable',
+	'http_407'                 => 'Proxy Authentication Required',
+	'http_408'                 => 'Request Timeout',
+	'http_409'                 => 'Conflict',
+	'http_410'                 => 'Gone',
+	'http_411'                 => 'Length Required',
+	'http_412'                 => 'Precondition Failed',
+	'http_413'                 => 'Payload Too Large',
+	'http_414'                 => 'URI Too Long',
+	'http_415'                 => 'Unsupported Media Type',
+	'http_416'                 => 'Range Not Satisfiable',
+	'http_417'                 => 'Expectation Failed',
+	'http_421'                 => 'Misdirected Request',
+	'http_422'                 => 'Unprocessable Entity',
+	'http_423'                 => 'Locked',
+	'http_424'                 => 'Failed Dependency',
+	'http_425'                 => 'Too Early',
+	'http_426'                 => 'Upgrade Required',
+	'http_428'                 => 'Precondition Required',
+	'http_429'                 => 'Too Many Requests',
+	'http_431'                 => 'Request Header Fields Too Large',
+	'http_451'                 => 'Unavailable For Legal Reasons',
+	'http_500'                 => 'Internal Server Error',
+	'http_501'                 => 'Not Implemented',
+	'http_502'                 => 'Bad Gateway',
+	'http_503'                 => 'Service Unavailable',
+	'http_504'                 => 'Gateway Timeout',
+	'http_505'                 => 'HTTP Version Not Supported',
+	'http_506'                 => 'Variant Also Negotiates',
+	'http_507'                 => 'Insufficient Storage',
+	'http_508'                 => 'Loop Detected',
+	'http_509'                 => 'Unassigned',
+	'http_510'                 => 'Not Extended',
+	'http_511'                 => 'Network Authentication Required',
 ];

src/lang/en/builder.php

Indentation +48 added lines, -48 removed lines

@@ -10,55 +10,55 @@
  */
 return [
 
-    'ok'                       => 'OK',
-    'no_error_message'         => 'Error #:api_code',
+	'ok'                       => 'OK',
+	'no_error_message'         => 'Error #:api_code',
 
-    // Used by Exception Handler Helper (when used)
-    'uncaught_exception'       => 'Uncaught exception: :message',
-    'http_exception'           => 'HTTP exception: :message',
+	// Used by Exception Handler Helper (when used)
+	'uncaught_exception'       => 'Uncaught exception: :message',
+	'http_exception'           => 'HTTP exception: :message',
 
-    // HttpException handler (added in 6.4.0)
-    // Error messages for HttpException caught w/o custom messages
-    // https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
-    'http_400'                 => 'Bad Request',
-    'http_401'                 => 'Unauthorized',
-    'http_402'                 => 'Payment Required',
-    'http_403'                 => 'Forbidden',
-    'http_404'                 => 'Not Found',
-    'http_405'                 => 'Method Not Allowed',
-    'http_406'                 => 'Not Acceptable',
-    'http_407'                 => 'Proxy Authentication Required',
-    'http_408'                 => 'Request Timeout',
-    'http_409'                 => 'Conflict',
-    'http_410'                 => 'Gone',
-    'http_411'                 => 'Length Required',
-    'http_412'                 => 'Precondition Failed',
-    'http_413'                 => 'Payload Too Large',
-    'http_414'                 => 'URI Too Long',
-    'http_415'                 => 'Unsupported Media Type',
-    'http_416'                 => 'Range Not Satisfiable',
-    'http_417'                 => 'Expectation Failed',
-    'http_421'                 => 'Misdirected Request',
-    'http_422'                 => 'Unprocessable Entity',
-    'http_423'                 => 'Locked',
-    'http_424'                 => 'Failed Dependency',
-    'http_425'                 => 'Too Early',
-    'http_426'                 => 'Upgrade Required',
-    'http_428'                 => 'Precondition Required',
-    'http_429'                 => 'Too Many Requests',
-    'http_431'                 => 'Request Header Fields Too Large',
-    'http_451'                 => 'Unavailable For Legal Reasons',
-    'http_500'                 => 'Internal Server Error',
-    'http_501'                 => 'Not Implemented',
-    'http_502'                 => 'Bad Gateway',
-    'http_503'                 => 'Service Unavailable',
-    'http_504'                 => 'Gateway Timeout',
-    'http_505'                 => 'HTTP Version Not Supported',
-    'http_506'                 => 'Variant Also Negotiates',
-    'http_507'                 => 'Insufficient Storage',
-    'http_508'                 => 'Loop Detected',
-    'http_509'                 => 'Unassigned',
-    'http_510'                 => 'Not Extended',
-    'http_511'                 => 'Network Authentication Required',
+	// HttpException handler (added in 6.4.0)
+	// Error messages for HttpException caught w/o custom messages
+	// https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
+	'http_400'                 => 'Bad Request',
+	'http_401'                 => 'Unauthorized',
+	'http_402'                 => 'Payment Required',
+	'http_403'                 => 'Forbidden',
+	'http_404'                 => 'Not Found',
+	'http_405'                 => 'Method Not Allowed',
+	'http_406'                 => 'Not Acceptable',
+	'http_407'                 => 'Proxy Authentication Required',
+	'http_408'                 => 'Request Timeout',
+	'http_409'                 => 'Conflict',
+	'http_410'                 => 'Gone',
+	'http_411'                 => 'Length Required',
+	'http_412'                 => 'Precondition Failed',
+	'http_413'                 => 'Payload Too Large',
+	'http_414'                 => 'URI Too Long',
+	'http_415'                 => 'Unsupported Media Type',
+	'http_416'                 => 'Range Not Satisfiable',
+	'http_417'                 => 'Expectation Failed',
+	'http_421'                 => 'Misdirected Request',
+	'http_422'                 => 'Unprocessable Entity',
+	'http_423'                 => 'Locked',
+	'http_424'                 => 'Failed Dependency',
+	'http_425'                 => 'Too Early',
+	'http_426'                 => 'Upgrade Required',
+	'http_428'                 => 'Precondition Required',
+	'http_429'                 => 'Too Many Requests',
+	'http_431'                 => 'Request Header Fields Too Large',
+	'http_451'                 => 'Unavailable For Legal Reasons',
+	'http_500'                 => 'Internal Server Error',
+	'http_501'                 => 'Not Implemented',
+	'http_502'                 => 'Bad Gateway',
+	'http_503'                 => 'Service Unavailable',
+	'http_504'                 => 'Gateway Timeout',
+	'http_505'                 => 'HTTP Version Not Supported',
+	'http_506'                 => 'Variant Also Negotiates',
+	'http_507'                 => 'Insufficient Storage',
+	'http_508'                 => 'Loop Detected',
+	'http_509'                 => 'Unassigned',
+	'http_510'                 => 'Not Extended',
+	'http_511'                 => 'Network Authentication Required',
 ];
 

src/BaseApiCodes.php

Indentation +175 added lines, -175 removed lines

@@ -21,180 +21,180 @@
  */
 class BaseApiCodes
 {
-    use ApiCodesHelpers;
-
-    /**
-     * protected code range - lowest code for reserved range.
-     *
-     * @var int
-     */
-    public const RESERVED_MIN_API_CODE_OFFSET = 0;
-
-    /**
-     * protected code range - highest code for reserved range
-     *
-     * @var int
-     */
-    public const RESERVED_MAX_API_CODE_OFFSET = 19;
-
-    /**
-     * built-in codes: OK
-     *
-     * @var int
-     */
-    protected const OK_OFFSET = 0;
-    /**
-     * built-in code for fallback message mapping
-     *
-     * @var int
-     */
-    protected const NO_ERROR_MESSAGE_OFFSET = 1;
-    /**
-     * built-in error code for HTTP_NOT_FOUND exception
-     *
-     * @var int
-     */
-    protected const EX_HTTP_NOT_FOUND_OFFSET = 10;
-    /**
-     * built-in error code for HTTP_SERVICE_UNAVAILABLE exception
-     *
-     * @var int
-     */
-    protected const EX_HTTP_SERVICE_UNAVAILABLE_OFFSET = 11;
-    /**
-     * built-in error code for HTTP_EXCEPTION
-     *
-     * @var int
-     */
-    protected const EX_HTTP_EXCEPTION_OFFSET = 12;
-    /**
-     * built-in error code for UNCAUGHT_EXCEPTION
-     *
-     * @var int
-     */
-    protected const EX_UNCAUGHT_EXCEPTION_OFFSET = 13;
-
-    /**
-     * built-in error code for \Illuminate\Auth\AuthenticationException
-     *
-     * @var int
-     */
-    protected const EX_AUTHENTICATION_EXCEPTION_OFFSET = 14;
-
-    /**
-     * built-in error code for \Illuminate\Auth\AuthenticationException
-     *
-     * @var int
-     */
-    protected const EX_VALIDATION_EXCEPTION_OFFSET = 15;
-
-    /**
-     * Returns base code mapping array
-     *
-     * @return array
-     */
-    protected static function getBaseMap(): array
-    {
-        $tpl = 'response-builder::builder.http_%d';
-
-        return [
-            self::OK()                          => 'response-builder::builder.ok',
-            self::NO_ERROR_MESSAGE()            => 'response-builder::builder.no_error_message',
-            self::EX_HTTP_EXCEPTION()           => 'response-builder::builder.http_exception',
-            self::EX_UNCAUGHT_EXCEPTION()       => 'response-builder::builder.uncaught_exception',
-            self::EX_HTTP_NOT_FOUND()           => sprintf($tpl, HttpResponse::HTTP_NOT_FOUND),
-            self::EX_HTTP_SERVICE_UNAVAILABLE() => sprintf($tpl, HttpResponse::HTTP_SERVICE_UNAVAILABLE),
-            self::EX_AUTHENTICATION_EXCEPTION() => sprintf($tpl, HttpResponse::HTTP_UNAUTHORIZED),
-            self::EX_VALIDATION_EXCEPTION()     => sprintf($tpl, HttpResponse::HTTP_UNPROCESSABLE_ENTITY),
-        ];
-    }
-
-    /**
-     * Returns API code for internal code OK
-     *
-     * @return int valid API code in current range
-     */
-    public static function OK(): int
-    {
-        return static::getCodeForInternalOffset(static::OK_OFFSET);
-    }
-
-    /**
-     * Returns API code for internal code NO_ERROR_MESSAGE
-     *
-     * @return int valid API code in current range
-     */
-    public static function NO_ERROR_MESSAGE(): int
-    {
-        return static::getCodeForInternalOffset(static::NO_ERROR_MESSAGE_OFFSET);
-    }
-
-    /**
-     * Returns API code for internal code EX_HTTP_NOT_FOUND
-     *
-     * @return int valid API code in current range
-     *
-     * @deprecated Configure Exception Handler to use your own API code.
-     */
-    public static function EX_HTTP_NOT_FOUND(): int
-    {
-        return static::getCodeForInternalOffset(static::EX_HTTP_NOT_FOUND_OFFSET);
-    }
-
-    /**
-     * Returns API code for internal code EX_HTTP_EXCEPTION
-     *
-     * @return int valid API code in current range
-     */
-    public static function EX_HTTP_EXCEPTION(): int
-    {
-        return static::getCodeForInternalOffset(static::EX_HTTP_EXCEPTION_OFFSET);
-    }
-
-    /**
-     * Returns API code for internal code EX_UNCAUGHT_EXCEPTION
-     *
-     * @return int valid API code in current range
-     */
-    public static function EX_UNCAUGHT_EXCEPTION(): int
-    {
-        return static::getCodeForInternalOffset(static::EX_UNCAUGHT_EXCEPTION_OFFSET);
-    }
-
-    /**
-     * Returns API code for internal code EX_AUTHENTICATION_EXCEPTION
-     *
-     * @return int valid API code in current range
-     *
-     * @deprecated Configure Exception Handler to use your own API code.
-     */
-    public static function EX_AUTHENTICATION_EXCEPTION(): int
-    {
-        return static::getCodeForInternalOffset(static::EX_AUTHENTICATION_EXCEPTION_OFFSET);
-    }
-
-    /**
-     * Returns API code for internal code EX_VALIDATION_EXCEPTION
-     *
-     * @return int valid API code in current range
-     *
-     * @deprecated Configure Exception Handler to use your own API code.
-     */
-    public static function EX_VALIDATION_EXCEPTION(): int
-    {
-        return static::getCodeForInternalOffset(static::EX_VALIDATION_EXCEPTION_OFFSET);
-    }
-
-    /**
-     * Returns API code for internal code EX_HTTP_SERVICE_UNAVAILABLE
-     *
-     * @return int valid API code in current range
-     *
-     * @deprecated Configure Exception Handler to use your own API code.
-     */
-    public static function EX_HTTP_SERVICE_UNAVAILABLE(): int
-    {
-        return static::getCodeForInternalOffset(static::EX_HTTP_SERVICE_UNAVAILABLE_OFFSET);
-    }
+	use ApiCodesHelpers;
+
+	/**
+	 * protected code range - lowest code for reserved range.
+	 *
+	 * @var int
+	 */
+	public const RESERVED_MIN_API_CODE_OFFSET = 0;
+
+	/**
+	 * protected code range - highest code for reserved range
+	 *
+	 * @var int
+	 */
+	public const RESERVED_MAX_API_CODE_OFFSET = 19;
+
+	/**
+	 * built-in codes: OK
+	 *
+	 * @var int
+	 */
+	protected const OK_OFFSET = 0;
+	/**
+	 * built-in code for fallback message mapping
+	 *
+	 * @var int
+	 */
+	protected const NO_ERROR_MESSAGE_OFFSET = 1;
+	/**
+	 * built-in error code for HTTP_NOT_FOUND exception
+	 *
+	 * @var int
+	 */
+	protected const EX_HTTP_NOT_FOUND_OFFSET = 10;
+	/**
+	 * built-in error code for HTTP_SERVICE_UNAVAILABLE exception
+	 *
+	 * @var int
+	 */
+	protected const EX_HTTP_SERVICE_UNAVAILABLE_OFFSET = 11;
+	/**
+	 * built-in error code for HTTP_EXCEPTION
+	 *
+	 * @var int
+	 */
+	protected const EX_HTTP_EXCEPTION_OFFSET = 12;
+	/**
+	 * built-in error code for UNCAUGHT_EXCEPTION
+	 *
+	 * @var int
+	 */
+	protected const EX_UNCAUGHT_EXCEPTION_OFFSET = 13;
+
+	/**
+	 * built-in error code for \Illuminate\Auth\AuthenticationException
+	 *
+	 * @var int
+	 */
+	protected const EX_AUTHENTICATION_EXCEPTION_OFFSET = 14;
+
+	/**
+	 * built-in error code for \Illuminate\Auth\AuthenticationException
+	 *
+	 * @var int
+	 */
+	protected const EX_VALIDATION_EXCEPTION_OFFSET = 15;
+
+	/**
+	 * Returns base code mapping array
+	 *
+	 * @return array
+	 */
+	protected static function getBaseMap(): array
+	{
+		$tpl = 'response-builder::builder.http_%d';
+
+		return [
+			self::OK()                          => 'response-builder::builder.ok',
+			self::NO_ERROR_MESSAGE()            => 'response-builder::builder.no_error_message',
+			self::EX_HTTP_EXCEPTION()           => 'response-builder::builder.http_exception',
+			self::EX_UNCAUGHT_EXCEPTION()       => 'response-builder::builder.uncaught_exception',
+			self::EX_HTTP_NOT_FOUND()           => sprintf($tpl, HttpResponse::HTTP_NOT_FOUND),
+			self::EX_HTTP_SERVICE_UNAVAILABLE() => sprintf($tpl, HttpResponse::HTTP_SERVICE_UNAVAILABLE),
+			self::EX_AUTHENTICATION_EXCEPTION() => sprintf($tpl, HttpResponse::HTTP_UNAUTHORIZED),
+			self::EX_VALIDATION_EXCEPTION()     => sprintf($tpl, HttpResponse::HTTP_UNPROCESSABLE_ENTITY),
+		];
+	}
+
+	/**
+	 * Returns API code for internal code OK
+	 *
+	 * @return int valid API code in current range
+	 */
+	public static function OK(): int
+	{
+		return static::getCodeForInternalOffset(static::OK_OFFSET);
+	}
+
+	/**
+	 * Returns API code for internal code NO_ERROR_MESSAGE
+	 *
+	 * @return int valid API code in current range
+	 */
+	public static function NO_ERROR_MESSAGE(): int
+	{
+		return static::getCodeForInternalOffset(static::NO_ERROR_MESSAGE_OFFSET);
+	}
+
+	/**
+	 * Returns API code for internal code EX_HTTP_NOT_FOUND
+	 *
+	 * @return int valid API code in current range
+	 *
+	 * @deprecated Configure Exception Handler to use your own API code.
+	 */
+	public static function EX_HTTP_NOT_FOUND(): int
+	{
+		return static::getCodeForInternalOffset(static::EX_HTTP_NOT_FOUND_OFFSET);
+	}
+
+	/**
+	 * Returns API code for internal code EX_HTTP_EXCEPTION
+	 *
+	 * @return int valid API code in current range
+	 */
+	public static function EX_HTTP_EXCEPTION(): int
+	{
+		return static::getCodeForInternalOffset(static::EX_HTTP_EXCEPTION_OFFSET);
+	}
+
+	/**
+	 * Returns API code for internal code EX_UNCAUGHT_EXCEPTION
+	 *
+	 * @return int valid API code in current range
+	 */
+	public static function EX_UNCAUGHT_EXCEPTION(): int
+	{
+		return static::getCodeForInternalOffset(static::EX_UNCAUGHT_EXCEPTION_OFFSET);
+	}
+
+	/**
+	 * Returns API code for internal code EX_AUTHENTICATION_EXCEPTION
+	 *
+	 * @return int valid API code in current range
+	 *
+	 * @deprecated Configure Exception Handler to use your own API code.
+	 */
+	public static function EX_AUTHENTICATION_EXCEPTION(): int
+	{
+		return static::getCodeForInternalOffset(static::EX_AUTHENTICATION_EXCEPTION_OFFSET);
+	}
+
+	/**
+	 * Returns API code for internal code EX_VALIDATION_EXCEPTION
+	 *
+	 * @return int valid API code in current range
+	 *
+	 * @deprecated Configure Exception Handler to use your own API code.
+	 */
+	public static function EX_VALIDATION_EXCEPTION(): int
+	{
+		return static::getCodeForInternalOffset(static::EX_VALIDATION_EXCEPTION_OFFSET);
+	}
+
+	/**
+	 * Returns API code for internal code EX_HTTP_SERVICE_UNAVAILABLE
+	 *
+	 * @return int valid API code in current range
+	 *
+	 * @deprecated Configure Exception Handler to use your own API code.
+	 */
+	public static function EX_HTTP_SERVICE_UNAVAILABLE(): int
+	{
+		return static::getCodeForInternalOffset(static::EX_HTTP_SERVICE_UNAVAILABLE_OFFSET);
+	}
 
 }

config/response_builder.php

Indentation +40 added lines, -40 removed lines

@@ -15,65 +15,65 @@ 
 use \Symfony\Component\HttpFoundation\Response as HttpResponse;
 
 return [
-    /*
+	/*
     |-----------------------------------------------------------------------------------------------------------
     | Code range settings
     |-----------------------------------------------------------------------------------------------------------
     */
-    'min_code'          => 100,
-    'max_code'          => 1024,
+	'min_code'          => 100,
+	'max_code'          => 1024,
 
-    /*
+	/*
     |-----------------------------------------------------------------------------------------------------------
     | Error code to message mapping
     |-----------------------------------------------------------------------------------------------------------
     |
     */
-    'map'               => [
-        // YOUR_API_CODE => '<MESSAGE_KEY>',
-    ],
+	'map'               => [
+		// YOUR_API_CODE => '<MESSAGE_KEY>',
+	],
 
-    /*
+	/*
     |-----------------------------------------------------------------------------------------------------------
     | Response Builder classes
     |-----------------------------------------------------------------------------------------------------------
     |
     */
-    'classes'           => [
-        \Illuminate\Database\Eloquent\Model::class          => [
-            'key'    => 'item',
-            'method' => 'toArray',
-        ],
-        \Illuminate\Support\Collection::class               => [
-            'key'    => 'items',
-            'method' => 'toArray',
-        ],
-        \Illuminate\Database\Eloquent\Collection::class     => [
-            'key'    => 'items',
-            'method' => 'toArray',
-        ],
-        \Illuminate\Http\Resources\Json\JsonResource::class => [
-            'key'    => 'item',
-            'method' => 'toArray',
-        ],
-    ],
+	'classes'           => [
+		\Illuminate\Database\Eloquent\Model::class          => [
+			'key'    => 'item',
+			'method' => 'toArray',
+		],
+		\Illuminate\Support\Collection::class               => [
+			'key'    => 'items',
+			'method' => 'toArray',
+		],
+		\Illuminate\Database\Eloquent\Collection::class     => [
+			'key'    => 'items',
+			'method' => 'toArray',
+		],
+		\Illuminate\Http\Resources\Json\JsonResource::class => [
+			'key'    => 'item',
+			'method' => 'toArray',
+		],
+	],
 
-    /*
+	/*
     |-----------------------------------------------------------------------------------------------------------
     | data-to-json encoding options
     |-----------------------------------------------------------------------------------------------------------
     |
     */
-    'encoding_options'  => JSON_HEX_TAG | JSON_HEX_APOS | JSON_HEX_AMP | JSON_HEX_QUOT | JSON_UNESCAPED_UNICODE,
+	'encoding_options'  => JSON_HEX_TAG | JSON_HEX_APOS | JSON_HEX_AMP | JSON_HEX_QUOT | JSON_UNESCAPED_UNICODE,
 
-    /*
+	/*
     |-----------------------------------------------------------------------------------------------------------
     | Exception handler error codes
     |-----------------------------------------------------------------------------------------------------------
     |
     */
-    'exception_handler' => [
-        /*
+	'exception_handler' => [
+		/*
          * HTTP Exceptions
          * Use this section to define how you want any Http Exception to be handled.
          * This means that you can define any Http code (i.e. 404 => HttpResponse::HTTP_NOT_FOUND)
@@ -104,20 +104,20 @@ 
 //            'api_code'  => BaseApiCodes::EX_UNCAUGHT_EXCEPTION(),
 //            'http_code' => HttpResponse::HTTP_INTERNAL_SERVER_ERROR,
 //        ],
-    ],
+	],
 
-    /*
+	/*
     |-----------------------------------------------------------------------------------------------------------
     | Debug config
     |-----------------------------------------------------------------------------------------------------------
     |
     */
-    'debug'             => [
-        'debug_key'         => 'debug',
-        'exception_handler' => [
-            'trace_key'     => 'trace',
-            'trace_enabled' => env('APP_DEBUG', false),
-        ],
-    ],
+	'debug'             => [
+		'debug_key'         => 'debug',
+		'exception_handler' => [
+			'trace_key'     => 'trace',
+			'trace_enabled' => env('APP_DEBUG', false),
+		],
+	],
 
 ];