App::group() - Code Metrics - Inspection of "Improvements" - kodeart/koded - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Pull Request — master (#3)

by Mihail

created 2023-10-18 21:20 UTC

App::group() A

↳ Parent: App

Complexity

Conditions	2
Paths	2

Size

Total Lines	16
Code Lines	8

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	6

Importance

Changes	3
Bugs	1	Features	2

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

<?php declare(strict_types=1);

namespace Koded\Framework;

use Closure;
use Error;
use Exception;
use InvalidArgumentException;
use Koded\DIContainer;
use Koded\Framework\Middleware\{CallableMiddleware, CorsMiddleware, GzipMiddleware};
use Koded\Http\Interfaces\{HttpStatus, Response};
use Koded\Http\HTTPError;
use Koded\Stdlib\Configuration;
use Psr\Http\Message\{ResponseInterface, ServerRequestInterface};
use Psr\Http\Server\{MiddlewareInterface, RequestHandlerInterface};
use Psr\Log\LoggerInterface;
use Whoops\Handler\PrettyPageHandler;
use stdClass;
use Throwable;
use TypeError;
use Whoops\Run as WoopsRunner;
use function array_keys;
use function array_merge;
use function array_values;
use function call_user_func_array;
use function date_default_timezone_set;
use function error_log;
use function function_exists;
use function get_class;
use function get_debug_type;
use function get_parent_class;
use function getenv;
use function is_a;
use function is_callable;
use function method_exists;
use function rawurldecode;
use function sprintf;

if (false === getenv('PRODUCTION')) {
    (new WoopsRunner)
        ->prependHandler(new PrettyPageHandler)
        ->register();
}

class App implements RequestHandlerInterface
{
    private int $offset = 0;
    /** @var array<int, MiddlewareInterface> */
    private array $stack = [];
    /** @var array<string, array> */
    private array $explicit = [];
    /** @var array<string, callable|null> */
    private array $handlers = [];
    private mixed $responder;
    private readonly DIContainer $container;

    public function __construct(
        array $modules = [],
        Configuration|string $config = '',
        private array $middleware = [],
        private mixed $renderer = 'start_response')
    {
        date_default_timezone_set('UTC');
        $this->withErrorHandler(HTTPError::class, [static::class, 'httpErrorHandler']);
        $this->withErrorHandler(Exception::class, [static::class, 'phpErrorHandler']);
        $this->withErrorHandler(Error::class, [static::class, 'phpErrorHandler']);
        $this->container = new DIContainer(new Module($config), ...$modules);
        $this->middleware = [new GzipMiddleware, ...$middleware, CorsMiddleware::class];
    }

    /**
     * @return mixed
     * @throws mixed
     */
    public function __invoke(): mixed
    {
        try {
            $request = $this->container
                ->new(ServerRequestInterface::class)
                ->withAttribute('@media', $this->container->get(Configuration::class)->get('media'));

            $this->responder = $this->responder($request, $uriTemplate);
            $this->initialize($uriTemplate);
            $response = $this->handle($request);
        } catch (Throwable $exception) {
            // [NOTE]: On exception, the state of the immutable request/response
            //  objects are not updated through the middleware "request phase",
            //  therefore the object attributes (and other properties) are lost
            $response = $this->container->get(ResponseInterface::class);
            if (false === $this->handleException($request, $response, $exception)) {
                throw $exception;
            }
        }
        // Share the response object for (custom) renderers
        $this->container->share($response);
        // [OPTIMIZATION]: Consider optimizing this
        $this->container->bind(Response::class, $response::class);
        return ($this->container)($this->renderer);
    }

    /**
     * @param ServerRequestInterface $request
     * @return ResponseInterface
     * @internal
     */
    public function handle(ServerRequestInterface $request): ResponseInterface
    {
        if (isset($this->stack[$this->offset])) {
            //\error_log('[mw:' . $this->offset . ']> ' . \get_debug_type($this->stack[$this->offset]));
            return $this->stack[$this->offset]->process($request, $this->next());
        }
        $this->container->share($request);
        return ($this->container)($this->responder);
    }

    /**
     * Create a route for URI.
     *
     * @param string                            $uriTemplate The URI template
     * @param object|string                     $resource    A PHP callable
     * @param array<MiddlewareInterface|string> $middleware  [optional] List of middlewares for this route
     * @param bool                              $explicit    [optional] If TRUE replace the global middlewares
     * @return self
     */
    public function route(
        string $uriTemplate,
        object|string $resource,
        array $middleware = [],
        bool $explicit = false): App
    {
        $this->container->get(Router::class)->route($uriTemplate, $resource);
        $this->explicit[$uriTemplate] = [$explicit, $middleware];
        return $this;
    }

    /**
     * Group multiple routes (adds prefix to all).
     * See App::route() method.
     *
     * @param string $prefix URI prefix for all routes in this group
     * @param array $routes A list of routes (@see App::route())
     * @param array<int, MiddlewareInterface|string> $middleware Additional middleware for all routes
     * @return self
     */
    public function group(
        string $prefix,
        array $routes,
        array $middleware = []): App
    {
        foreach ($routes as $route) {
            /**[ template, resource, middleware, explicit ]**/
            $route += ['', '', [], false];
            [$uriTemplate, $resource, $mw, $explicit] = $route;
            $this->route($prefix . $uriTemplate,
                $resource,
                array_merge($middleware, $mw),
                $explicit
            );
        }
        return $this;
    }

    public function withErrorHandler(string $type, callable|null $handler): App
    {
        if (false === is_a($type, Throwable::class, true)) {
            throw new TypeError(__('koded.handler.wrong.type'), HttpStatus::CONFLICT);
        }
        if (null === $handler && false === method_exists($type, 'handle')) {
            throw new TypeError(__('koded.handler.missing'), HttpStatus::NOT_IMPLEMENTED);
        }
        $this->handlers[$type] = $handler;
        return $this;
    }

    public function withoutErrorHandler(string $type): App
    {
        unset($this->handlers[$type]);
        return $this;
    }

    public function withErrorSerializer(callable $serializer): App
    {
        $this->container->named('$errorSerializer', $serializer);
        return $this;
    }

    private function next(): RequestHandlerInterface
    {
        $self = clone $this;
        $self->offset++;
        return $self;
    }

    private function initialize(?string $uriTemplate): void
    {
        $this->offset = 0;
        $this->stack = [];
        if (empty($uriTemplate)) {
            // Always support CORS requests
            $this->explicit[$uriTemplate] = [true, [CorsMiddleware::class]];
        }
        [$explicit, $middleware] = $this->explicit[$uriTemplate] + [true];
        $this->middleware = false === $explicit ? [...$this->middleware, ...$middleware] : $middleware;
        foreach ($this->middleware as $middleware) {
            $class = 'string' === get_debug_type($middleware) ? $middleware : get_class($middleware);
            $this->stack[$class] = match (true) {
                $middleware instanceof MiddlewareInterface => $middleware,
                is_a($middleware, MiddlewareInterface::class, true) => $this->container->new($middleware),
                is_callable($middleware) => new CallableMiddleware($middleware),
                default => throw new InvalidArgumentException(
                    __('koded.middleware.implements', [
                        $class, MiddlewareInterface::class
                    ])
                )
            };
        }
        $this->stack = array_values($this->stack);
    }

    private function responder(
        ServerRequestInterface &$request,
        string|null &$uriTemplate): callable
    {
        $path = rawurldecode($request->getUri()->getPath());
        $match = $this->container->get(Router::class)->match($path);
        $uriTemplate = $match['template'] ?? null;
        $resource = $match['resource'] ?? null;
        $allowed = array_keys(map_http_methods($resource ?? new stdClass));
        $request = $request->withAttribute('@http_methods', $allowed);
        foreach ($match['params'] ?? [] as $name => $value) {
            $request = $request->withAttribute($name, $value);
        }
        $this->container->get(LoggerInterface::class)->debug('> {method} {path}', [
            'method' => $request->getMethod(),
            'path' => $path
        ]);
        if ('OPTIONS' === $method = $request->getMethod()) {
            return create_options_response($allowed);
        }
        if (empty($resource)) {
            return path_not_found($path);
        }
        if ('HEAD' === $method) {
            return head_response((string)$request->getUri(), $allowed);
        }
        if ($resource instanceof Closure || function_exists($resource)) {
            return $resource;
        }
        $responder = $this->container->new($resource);
        if (false === method_exists($responder, $method)) {
            return method_not_allowed($allowed);
        }
        return [$responder, $method];
    }

    private function handleException(
        ServerRequestInterface $request,
        ResponseInterface &$response,
        Throwable $ex): bool
    {
        if (!$handler = $this->findErrorHandler($ex)) {
            return false;
        }
        try {
            call_user_func_array($handler, [$request, &$response, $ex]);
        } catch (HTTPError $error) {
            $this->composeErrorResponse($request, $response, $error);
        }
        return true;
    }

    private function findErrorHandler($ex): callable|null
    {
        $parents = [get_debug_type($ex)];
        // Iterate the class inheritance chain
        (static function($class) use (&$parents) {
            while ($class = get_parent_class($class)) {
                $parents[] = $class;
            }
        })($ex);
        // Find the parent that matches the exception type
        foreach ($parents as $parent) {
            if (isset($this->handlers[$parent]) && is_a($ex, $parent, true)) {
                return $this->handlers[$parent];
            }
        }
        return null;
    }

    private function phpErrorHandler(
        ServerRequestInterface $request,
        ResponseInterface &$response,
        Throwable $ex): void
    {
        error_log(sprintf("[%s] %s\n%s",
                            $title = get_debug_type($ex),
                            $ex->getMessage(),
                            $ex->getTraceAsString()));

        $this->composeErrorResponse(
            $request,
            $response,
            new HTTPError(HTTPError::status($ex, HttpStatus::CONFLICT),
                title:    $title,
                detail:   $ex->getMessage(),
                previous: $ex
            ));
    }

    private function httpErrorHandler(
        ServerRequestInterface $request,
        ResponseInterface &$response,
        HTTPError $ex): void
    {
        $this->composeErrorResponse($request, $response, $ex);
    }

    private function composeErrorResponse(
        ServerRequestInterface $request,
        ResponseInterface &$response,
        HTTPError $ex): void
    {
        $response = $response->withStatus($ex->getCode())
            ->withAddedHeader('Vary', 'Content-Type');

        foreach ($ex->getHeaders() as $name => $value) {
            $response = $response->withHeader($name, $value);
        }
        // Process middleware
        $this->responder = fn() => $response;
        $this->initialize(null);
        $response = $this->handle($request);

        try {
            $response = call_user_func_array(
                $this->container->get('$errorSerializer'),
                [$request, &$response, $ex]
            );
        } catch (Throwable) {
            // Fallback if error handler does not exist
            $response = default_serialize_error($request, $response, $ex);
        }
    }
}


1		<?php declare(strict_types=1);
2
3		namespace Koded\Framework;
4
5		use Closure;
6		use Error;
7		use Exception;
8		use InvalidArgumentException;
9		use Koded\DIContainer;
10		use Koded\Framework\Middleware\{CallableMiddleware, CorsMiddleware, GzipMiddleware};
11		use Koded\Http\Interfaces\{HttpStatus, Response};
12		use Koded\Http\HTTPError;
13		use Koded\Stdlib\Configuration;
14		use Psr\Http\Message\{ResponseInterface, ServerRequestInterface};
15		use Psr\Http\Server\{MiddlewareInterface, RequestHandlerInterface};
16		use Psr\Log\LoggerInterface;
17		use Whoops\Handler\PrettyPageHandler;
18		use stdClass;
19		use Throwable;
20		use TypeError;
21		use Whoops\Run as WoopsRunner;
22		use function array_keys;
23		use function array_merge;
24		use function array_values;
25		use function call_user_func_array;
26		use function date_default_timezone_set;
27		use function error_log;
28		use function function_exists;
29		use function get_class;
30		use function get_debug_type;
31		use function get_parent_class;
32		use function getenv;
33		use function is_a;
34		use function is_callable;
35		use function method_exists;
36		use function rawurldecode;
37		use function sprintf;
38	1
39	1	if (false === getenv('PRODUCTION')) {
40	1	(new WoopsRunner)
41		->prependHandler(new PrettyPageHandler)
42		->register();
43		}
44
45		class App implements RequestHandlerInterface
46		{
47		private int $offset = 0;
48		/** @var array<int, MiddlewareInterface> */
49		private array $stack = [];
50		/** @var array<string, array> */
51		private array $explicit = [];
52		/** @var array<string, callable\|null> */
53		private array $handlers = [];
54	36	private mixed $responder;
55		private readonly DIContainer $container;
56
57		public function __construct(
58		array $modules = [],
59		Configuration\|string $config = '',
60	36	private array $middleware = [],
61	36	private mixed $renderer = 'start_response')
62	36	{
63	36	date_default_timezone_set('UTC');
64	36	$this->withErrorHandler(HTTPError::class, [static::class, 'httpErrorHandler']);
65	36	$this->withErrorHandler(Exception::class, [static::class, 'phpErrorHandler']);
66		$this->withErrorHandler(Error::class, [static::class, 'phpErrorHandler']);
67		$this->container = new DIContainer(new Module($config), ...$modules);
68		$this->middleware = [new GzipMiddleware, ...$middleware, CorsMiddleware::class];
69		}
70
71		/**
72	36	* @return mixed
73		* @throws mixed
74		*/
75	36	public function __invoke(): mixed
76	36	{
77	36	try {
78		$request = $this->container
79	36	->new(ServerRequestInterface::class)
80	34	->withAttribute('@media', $this->container->get(Configuration::class)->get('media'));
81	34
82	5	$this->responder = $this->responder($request, $uriTemplate);
83		$this->initialize($uriTemplate);
84		$response = $this->handle($request);
85		} catch (Throwable $exception) {
86	5	// [NOTE]: On exception, the state of the immutable request/response
87	5	// objects are not updated through the middleware "request phase",
88	1	// therefore the object attributes (and other properties) are lost
89		$response = $this->container->get(ResponseInterface::class);
90		if (false === $this->handleException($request, $response, $exception)) {
91		throw $exception;
92	35	}
93		}
94	35	// Share the response object for (custom) renderers
95	35	$this->container->share($response);
96		// [OPTIMIZATION]: Consider optimizing this
97		$this->container->bind(Response::class, $response::class);
98		return ($this->container)($this->renderer);
99		}
100
101		/**
102		* @param ServerRequestInterface $request
103	36	* @return ResponseInterface
104		* @internal
105	36	*/
106		public function handle(ServerRequestInterface $request): ResponseInterface
107	36	{
108		if (isset($this->stack[$this->offset])) {
109	36	//\error_log('[mw:' . $this->offset . ']> ' . \get_debug_type($this->stack[$this->offset]));
110	36	return $this->stack[$this->offset]->process($request, $this->next());
111		}
112		$this->container->share($request);
113		return ($this->container)($this->responder);
114		}
115
116		/**
117		* Create a route for URI.
118		*
119		* @param string $uriTemplate The URI template
120		* @param object\|string $resource A PHP callable
121		* @param array<MiddlewareInterface\|string> $middleware [optional] List of middlewares for this route
122	35	* @param bool $explicit [optional] If TRUE replace the global middlewares
123		* @return self
124		*/
125		public function route(
126		string $uriTemplate,
127		object\|string $resource,
128		array $middleware = [],
129	35	bool $explicit = false): App
130	35	{
131	35	$this->container->get(Router::class)->route($uriTemplate, $resource);
132		$this->explicit[$uriTemplate] = [$explicit, $middleware];
133		return $this;
134		}
135
136		/**
137		* Group multiple routes (adds prefix to all).
138		* See App::route() method.
139		*
140		* @param string $prefix URI prefix for all routes in this group
141		* @param array $routes A list of routes (@see App::route())
142		* @param array<int, MiddlewareInterface\|string> $middleware Additional middleware for all routes
143		* @return self
144		*/
145		public function group(
146		string $prefix,
147		array $routes,
148		array $middleware = []): App
149		{
150		foreach ($routes as $route) {
151		/[ template, resource, middleware, explicit ]/
152		$route += ['', '', [], false];
153		[$uriTemplate, $resource, $mw, $explicit] = $route;
154		$this->route($prefix . $uriTemplate,
155		$resource,
156		array_merge($middleware, $mw),
157		$explicit
158		);
159		}
160		return $this;
161		}
162
163		public function withErrorHandler(string $type, callable\|null $handler): App
164		{
165		if (false === is_a($type, Throwable::class, true)) {
166		throw new TypeError(__('koded.handler.wrong.type'), HttpStatus::CONFLICT);
167		}
168		if (null === $handler && false === method_exists($type, 'handle')) {
169	36	throw new TypeError(__('koded.handler.missing'), HttpStatus::NOT_IMPLEMENTED);
170		}
171	36	$this->handlers[$type] = $handler;
172		return $this;
173		}
174	36
175		public function withoutErrorHandler(string $type): App
176		{
177		unset($this->handlers[$type]);
178		return $this;
179	36	}
180	36
181		public function withErrorSerializer(callable $serializer): App
182		{
183	1	$this->container->named('$errorSerializer', $serializer);
184		return $this;
185	1	}
186	1
187		private function next(): RequestHandlerInterface
188		{
189		$self = clone $this;
190		$self->offset++;
191		return $self;
192		}
193
194		private function initialize(?string $uriTemplate): void
195	36	{
196		$this->offset = 0;
197	36	$this->stack = [];
198	36	if (empty($uriTemplate)) {
199	36	// Always support CORS requests
200		$this->explicit[$uriTemplate] = [true, [CorsMiddleware::class]];
201		}
202	36	[$explicit, $middleware] = $this->explicit[$uriTemplate] + [true];
203		$this->middleware = false === $explicit ? [...$this->middleware, ...$middleware] : $middleware;
204	36	foreach ($this->middleware as $middleware) {
205	36	$class = 'string' === get_debug_type($middleware) ? $middleware : get_class($middleware);
206	36	$this->stack[$class] = match (true) {
207		$middleware instanceof MiddlewareInterface => $middleware,
208	4	is_a($middleware, MiddlewareInterface::class, true) => $this->container->new($middleware),
209		is_callable($middleware) => new CallableMiddleware($middleware),
210	36	default => throw new InvalidArgumentException(
211	36	__('koded.middleware.implements', [
212	36	$class, MiddlewareInterface::class
213	36	])
214	36	)
215	36	};
216	36	}
217	36	$this->stack = array_values($this->stack);
218	36	}
219	36
220	36	private function responder(
221	36	ServerRequestInterface &$request,
222		string\|null &$uriTemplate): callable
223	36	{
224		$path = rawurldecode($request->getUri()->getPath());
225		$match = $this->container->get(Router::class)->match($path);
226	36	$uriTemplate = $match['template'] ?? null;
227		$resource = $match['resource'] ?? null;
228		$allowed = array_keys(map_http_methods($resource ?? new stdClass));
229		$request = $request->withAttribute('@http_methods', $allowed);
230	36	foreach ($match['params'] ?? [] as $name => $value) {
231	36	$request = $request->withAttribute($name, $value);
232	36	}
233	36	$this->container->get(LoggerInterface::class)->debug('> {method} {path}', [
234	36	'method' => $request->getMethod(),
235	36	'path' => $path
236	36	]);
237		if ('OPTIONS' === $method = $request->getMethod()) {
238		return create_options_response($allowed);
239	36	}
240	36	if (empty($resource)) {
241	36	return path_not_found($path);
242	36	}
243	36	if ('HEAD' === $method) {
244	7	return head_response((string)$request->getUri(), $allowed);
245		}
246	29	if ($resource instanceof Closure \|\| function_exists($resource)) {
247	1	return $resource;
248		}
249	28	$responder = $this->container->new($resource);
250		if (false === method_exists($responder, $method)) {
251		return method_not_allowed($allowed);
252	28	}
253	14	return [$responder, $method];
254		}
255	14
256	14	private function handleException(
257	1	ServerRequestInterface $request,
258		ResponseInterface &$response,
259	13	Throwable $ex): bool
260		{
261		if (!$handler = $this->findErrorHandler($ex)) {
262	5	return false;
263		}
264		try {
265		call_user_func_array($handler, [$request, &$response, $ex]);
266		} catch (HTTPError $error) {
267	5	$this->composeErrorResponse($request, $response, $error);
268	1	}
269		return true;
270		}
271	4
272		private function findErrorHandler($ex): callable\|null
273		{
274		$parents = [get_debug_type($ex)];
275	4	// Iterate the class inheritance chain
276		(static function($class) use (&$parents) {
277		while ($class = get_parent_class($class)) {
278	5	$parents[] = $class;
279		}
280	5	})($ex);
281		// Find the parent that matches the exception type
282	5	foreach ($parents as $parent) {
283	5	if (isset($this->handlers[$parent]) && is_a($ex, $parent, true)) {
284	3	return $this->handlers[$parent];
285		}
286	5	}
287		return null;
288	5	}
289	5
290	4	private function phpErrorHandler(
291		ServerRequestInterface $request,
292		ResponseInterface &$response,
293	1	Throwable $ex): void
294		{
295		error_log(sprintf("[%s] %s\n%s",
296	1	$title = get_debug_type($ex),
297		$ex->getMessage(),
298		$ex->getTraceAsString()));
299
300		$this->composeErrorResponse(
301	1	$request,
302	1	$response,
303	1	new HTTPError(HTTPError::status($ex, HttpStatus::CONFLICT),
304	1	title: $title,
305		detail: $ex->getMessage(),
306	1	previous: $ex
307	1	));
308	1	}
309	1
310	1	private function httpErrorHandler(
311	1	ServerRequestInterface $request,
312	1	ResponseInterface &$response,
313	1	HTTPError $ex): void
314		{
315		$this->composeErrorResponse($request, $response, $ex);
316	3	}
317
318		private function composeErrorResponse(
319		ServerRequestInterface $request,
320		ResponseInterface &$response,
321	3	HTTPError $ex): void
322		{
323		$response = $response->withStatus($ex->getCode())
324	4	->withAddedHeader('Vary', 'Content-Type');
325
326		foreach ($ex->getHeaders() as $name => $value) {
327		$response = $response->withHeader($name, $value);
328		}
329	4	// Process middleware
330	4	$this->responder = fn() => $response;
331		$this->initialize(null);
332	4	$response = $this->handle($request);
333	1
334		try {
335		$response = call_user_func_array(
336	4	$this->container->get('$errorSerializer'),
337	4	[$request, &$response, $ex]
338	4	);
339		} catch (Throwable) {
340		// Fallback if error handler does not exist
341	4	$response = default_serialize_error($request, $response, $ex);
342	4	}
343	4	}
344		}
345

kodeart / koded

Pull Request — master (#3)

App::group() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like