Apitte skeleton – nelogguje errory a jen zobrazi error 500

Ahoj,

začal jsem používat apitte-skeleton jako backend pro mojí aplikaci a neloggují se mi errory. Nejspíš to bude nějaká chyba v Middlewares, ale nenapadá mě co. Posílám moje soubory, ale většinou to je podobné apitte-skeletonu. Jestli je potřeba ještě něco, rád pošlu.

apitte.neon

extensions:
    middlewares: Contributte\Middlewares\DI\MiddlewaresExtension
    resource: Contributte\DI\Extension\ResourceExtension
    api: Apitte\Core\DI\ApiExtension

resource:
    resources:
        App\Module\Api\:
            paths:
                - %appDir%/Module/Api
            decorator:
                inject: true
        App\Module\Backend\:
            paths:
                - %appDir%/Module/Backend
            decorator:
                inject: true

api:
    debug: false
    plugins:
        Apitte\Core\DI\Plugin\CoreSchemaPlugin:
        Apitte\Core\DI\Plugin\CoreServicesPlugin:
        Apitte\OpenApi\DI\OpenApiPlugin:
        Apitte\Debug\DI\DebugPlugin:
        Apitte\Middlewares\DI\MiddlewaresPlugin:
            tracy: false
            autobasepath: false

services:
    middleware.tryCatch:
        create: Contributte\Middlewares\TryCatchMiddleware
        tags: [middleware: [priority: 1]]
        setup:
            - setDebugMode(%debugMode%)
            - setCatchExceptions(%productionMode%) # used in debug only
    middlewares.logging:
        create: Contributte\Middlewares\LoggingMiddleware
        arguments: [@monolog.logger.default]
        tags: [middleware: [priority: 100]]
    middleware.methodOverride:
        create: Contributte\Middlewares\MethodOverrideMiddleware
        tags: [middleware: [priority: 150]]
    middleware.authenticator:
        create: App\Model\Api\Middleware\AuthenticationMiddleware(
            App\Model\Api\Security\TokenAuthenticator(%api.bot.token%)
        )
        tags: [middleware: [priority: 200]]

    api.core.dispatcher: App\Model\Api\Dispatcher\JsonDispatcher

contributte.neon

extensions:
	console: Contributte\Console\DI\ConsoleExtension(%consoleMode%)
	monolog: Contributte\Monolog\DI\MonologExtension

console:
	url: http://localhost/
	lazy: true

monolog:
	holder:
		enabled: true

	channel:
		default:
			handlers:
				- Monolog\Handler\RotatingFileHandler(%logDir%/syslog.log, 30, Monolog\Logger::WARNING)

			processors:
				- Monolog\Processor\WebProcessor()
				- Monolog\Processor\IntrospectionProcessor()
				- Monolog\Processor\MemoryPeakUsageProcessor()
				- Monolog\Processor\ProcessIdProcessor()

JsonDispatcher

<?php

declare(strict_types=1);

namespace App\Model\Api\Dispatcher;

use Apitte\Core\Dispatcher\JsonDispatcher as ApitteJsonDispatcher;
use Apitte\Core\Handler\IHandler;
use Apitte\Core\Http\ApiRequest;
use Apitte\Core\Http\ApiResponse;
use Apitte\Core\Http\RequestAttributes;
use Apitte\Core\Router\IRouter;
use Apitte\Core\Schema\Endpoint;
use Nette\Utils\Json;
use Symfony\Component\Serializer\SerializerInterface;
use Symfony\Component\Validator\Validator\ValidatorInterface;

class JsonDispatcher extends ApitteJsonDispatcher
{
    /** @var SerializerInterface */
    protected SerializerInterface $serializer;

    /** @var ValidatorInterface */
    protected ValidatorInterface $validator;

    public function __construct(
        IRouter $router,
        IHandler $handler,
        SerializerInterface $serializer,
        ValidatorInterface $validator
    ) {
        parent::__construct($router, $handler);

        $this->serializer = $serializer;
        $this->validator = $validator;
    }

    protected function handle(ApiRequest $request, ApiResponse $response): ApiResponse
    {
        try {
            $request = $this->transformRequest($request);
            $result = $this->handler->handle($request, $response);

            // Except ResponseInterface convert all to json
            if (!($result instanceof ApiResponse)) {
                $response = $this->transformResponse($result, $response);
            } else {
                $response = $result;
            }
        } catch (\Apitte\Core\Exception\Api\ClientErrorException | \Apitte\Core\Exception\Api\ServerErrorException $e) {
            $data = [];

            if ($e->getMessage()) {
                $data['message'] = $e->getMessage();
            }
            if ($e->getContext()) {
                $data['context'] = $e->getContext();
            }
            if ($e->getCode()) {
                $data['code'] = $e->getCode();
            }

            $response = $response->withStatus($e->getCode() ?: 500)
                ->withHeader('Content-Type', 'application/json');
            $response->getBody()->write(Json::encode($data));
        } catch (\RuntimeException $e) {
            $response = $response->withStatus($e->getCode() ?: 500)
                ->withHeader('Content-Type', 'application/json');
            $response->getBody()->write(Json::encode([
                'message' => $e->getMessage() ?: 'Application encountered an internal error. Please try again later.',
            ]));
        }

        return $response;
    }

    /**
     * Transform incoming request to request DTO, if needed.
     */
    protected function transformRequest(ApiRequest $request): ApiRequest
    {
        // If Apitte endpoint is not provided, skip transforming.
        $endpoint = $request->getAttribute(RequestAttributes::ATTR_ENDPOINT);
        if (!$endpoint) {
            return $request;
        }

        // @safety
        \assert($endpoint instanceof Endpoint);

        // Get incoming request entity class, if defined. Otherwise, skip transforming.
        $entity = $endpoint->getTag('request.dto');
        if (!$entity) {
            return $request;
        }

        try {
            // Create request DTO from incoming request, using serializer.
            $dto = $this->serializer->deserialize(
                $request->getBody()->getContents(),
                $entity,
                'json',
                ['allow_extra_attributes' => false],
            );

            $request = $request->withParsedBody($dto);
        } catch (\Symfony\Component\Serializer\Exception\ExtraAttributesException $e) {
            throw \Apitte\Core\Exception\Api\ValidationException::create()
                ->withMessage($e->getMessage());
        }

        // Try to validate entity only if its enabled
        $violations = $this->validator->validate($dto);

        if (\count($violations) > 0) {
            $fields = [];
            foreach ($violations as $violation) {
                $fields[$violation->getPropertyPath()][] = $violation->getMessage();
            }

            throw \Apitte\Core\Exception\Api\ValidationException::create()
                ->withMessage('Invalid request data')
                ->withFields($fields);
        }

        return $request;
    }

    /**
     * Transform outgoing response data to JSON, if needed.
     *
     * @param mixed $data
     */
    protected function transformResponse($data, ApiResponse $response): ApiResponse
    {
        $response = $response->withStatus(200)
            ->withHeader('Content-Type', 'application/json');

        // Serialize entity with symfony/serializer to JSON
        $serialized = $this->serializer->serialize($data, 'json');

        $response->getBody()->write($serialized);

        return $response;
    }
}

AuthenticationMiddleware

<?php

declare(strict_types=1);

namespace App\Model\Api\Middleware;

use App\Model\Utils\Strings;
use Contributte\Middlewares\IMiddleware;
use Contributte\Middlewares\Security\IAuthenticator;
use Nette\Utils\Json;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;

class AuthenticationMiddleware implements IMiddleware
{
    private const WHITELIST_PATHS = ['/backend/v1/user/register', '/backend/v1/user/login', '/backend/v1/openapi'];

    /** @var IAuthenticator */
    private IAuthenticator $authenticator;

    public function __construct(IAuthenticator $authenticator)
    {
        $this->authenticator = $authenticator;
    }

    protected function denied(ServerRequestInterface $request, ResponseInterface $response): ResponseInterface
    {
        $response->getBody()->write(Json::encode([
            'status' => 'error',
            'message' => 'Client authentication failed',
            'code' => 401,
        ]));

        return $response
            ->withHeader('Content-Type', 'application/json')
            ->withStatus(401);
    }

    protected function isWhitelisted(ServerRequestInterface $request): bool
    {
        foreach (self::WHITELIST_PATHS as $whitelist) {
            if (Strings::startsWith($request->getUri()->getPath(), $whitelist)) {
                return true;
            }
        }

        return false;
    }

    /**
     * Authenticate user from given request
     */
    public function __invoke(
        ServerRequestInterface $request,
        ResponseInterface $response,
        callable $next
    ): ResponseInterface {
        if ($this->isWhitelisted($request)) {
            return $next($request, $response);
        }
        // If we have a identity, then go to next middlewares,
        // otherwise stop and return current response
        if (!$this->authenticator->authenticate($request)) {
            return $this->denied($request, $response);
        }

        // Pass to next middleware
        return $next($request, $response);
    }
}