Hello @odan,

Do you think your JWT authorization is compatible with this dependency? For role auth https://github.com/jaywilliams/slim-role-auth

It should be loaded after the JWT was authorized right? The role data should be inside the JWT?

Thanks!

Hi @odan, how are you?

In my tests, the ValidationException of validateUserUpdate() does not return the 'User not found' error message. Returns only the 422 error, but without the error message.

The validateUser() returns with the error message, and indicates which field is incorrect.

What is the correct way to solve this?

Thanks in advanced.

Hi i am following your wiki on: https://odan.github.io/slim4-skeleton/setup/docker.html but after i have created my application with:

composer create-project odan/slim4-skeleton my-app

the file docker-compose.yml will not create, and i can't run my docker container.

Anyone can help me?

Thank you

Cannot send request via Guzzle in home controller. It's weird, but when I add line var_dump($learners); I can see rendered response. Without var_dump page doesn't renders at all.

< HTTP/1.1 200 OK
< Date: Wed, 02 Sep 2020 10:53:40 GMT
< Server: Apache/2.4.34 (Unix) PHP/7.4.6
< X-Powered-By: PHP/7.4.6
< Cache-Control: max-age=0, private, must-revalidate
< Transfer-Encoding: chunked
< Content-Type: text/html; charset=UTF-8


* Received 1783 B chunk
* Illegal or missing hexadecimal sequence in chunked-encoding
* stopped the pause stream!
* Closing connection 20

<?php

namespace App\Action\Home;

use App\Responder\Responder;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;
use GuzzleHttp\Client;

/**
 * Action.
 */
final class HomeAction
{
    /**
     * @var Responder
     */
    private $responder;

    /**
     * The constructor.
     *
     * @param Responder $responder The responder
     */
    public function __construct(Responder $responder)
    {
        $this->responder = $responder;
    }

    /**
     * Action.
     *
     * @param ServerRequestInterface $request The request
     * @param ResponseInterface $response The response
     *
     * @return ResponseInterface The response
     */
    public function __invoke(ServerRequestInterface $request, ResponseInterface $response): ResponseInterface
    {
        $client = new Client();
        $learnersUrl = 'http://apitest.test/api/learners';// localhost
        $response = $client->request('GET', $learnersUrl);
        $learners = json_decode((string) $response->getBody(), true);
        // var_dump($learners);
        return $this->responder->render($response, 'home/home.twig', [
            'now' => date('d.m.Y H:i:s'),
        ]);
    }
}

Is there a way of communication to speak/ask question about this skeleton? I have some "generic" questions, but I don't want to abuse the issue system.

(Maybe by enabling the Discussions feature in this repos settings)

Hi

i have a middleware `<?php

namespace App\Middleware;

use Psr\Http\Message\ResponseInterface; use Psr\Http\Message\ServerRequestInterface; use Psr\Http\Server\MiddlewareInterface; use Psr\Http\Server\RequestHandlerInterface; use Slim\Views\Twig; use Symfony\Component\HttpFoundation\Session\Session;

final class OldInputMiddleware implements MiddlewareInterface {

private Twig $view;

private Session $session;
/**
 * @param $request
 * @param $response
 * @param $next
 * @return mixed
 */
public function __construct(Session $session,Twig $view)
{
    $this->session = $session;
    $this->view= $view;
}

public function process(ServerRequestInterface $request, RequestHandlerInterface $handler): ResponseInterface
{

    $tmp=$request->getParsedBody();
     var_dump($tmp);

    return $handler->handle($request);
}

}`

when i submit a form POST , the dump is empty , the getMethod is "GET"

`<?php

use App\Middleware\OldInputMiddleware; use App\Middleware\SessionMiddleware; use App\Middleware\UrlGeneratorMiddleware; use App\Middleware\ValidationErrorsMiddleware; use Selective\BasePath\BasePathMiddleware; use Selective\Validation\Middleware\ValidationExceptionMiddleware; use Slim\App; use Slim\Csrf\Guard; use Slim\Middleware\ErrorMiddleware; use Slim\Views\TwigMiddleware;

return function (App $app) {

$app->add(ValidationExceptionMiddleware::class); $app->add(Guard::class); $app->add(UrlGeneratorMiddleware::class);

$app->addRoutingMiddleware();

$app->add(TwigMiddleware::class);
$app->add(OldInputMiddleware::class); // EMPTY getParsedBody
$app->add(ValidationErrorsMiddleware::class);
$app->add(SessionMiddleware::class);
$app->add(BasePathMiddleware::class);
$app->addBodyParsingMiddleware();
$app->add(ErrorMiddleware::class);

};`

any idea ?

Is this possible to add a link to download with storage directory with slim 4 and how?

Ex. "Download" and Link is: (myweb/storage/04/download.zip).

Hey @odan

I went though your Tutorial, the Twig implementation and the Mailer Implementation. Would like to thank you for these awesome tutorials.

So good so far, but when I tried to use Twig inside emails, it simply doenst work. I was following the official documentation in Mailer, but I get an error: Type: Symfony\Component\Mime\Exception\LogicException Code: 0 Message: A message must have a text or an HTML part or attachments. File: /vendor/symfony/mime/Email.php Line: 405

I found a reference in this github: symfony/symfony#35990

If this is easy to solve, I guess it would be nice to be in your tutorials

I would like to share few VSCode snippets which I found very useful.

Snippets in Visual Studio Code - Create your own snippets

Route declaration snippet

    "slim4 skeleton route": {
        "prefix": [
            "$app->get",
            "$group->get"
        ],
        "body": [
            "// Route for /$1",
            "\\$${2|app,group|}->${3|get,post,put,patch,delete|}('/$1', \\App\\Action\\\\$4::class)->setName('${1/[^A-z^0-9^-]/:downcase/g}');"
        ],
        "description": "Route declaration for Slim4 skeleton"
    },

Generates line like:

// Route for /
$app->get('/', \App\Action\::class)->setName('');

Action Controller snippet

    "slim4 skeleton action class": {
        "prefix": "class",
        "body": [
            "namespace App\\Action\\\\${TM_DIRECTORY/^.+\\/(.*)$/$1/};",
            "",
            "use App\\Responder\\Responder;",
            "use Psr\\Http\\Message\\ResponseInterface;",
            "use Psr\\Http\\Message\\ServerRequestInterface;",
            "",
            "/**",
            " * Action.",
            " */",
            "final class $TM_FILENAME_BASE",
            "{",
            "    /**",
            "     * @var Responder",
            "     */",
            "    private \\$responder;",
            "",
            "    /**",
            "     * The constructor.",
            "     *",
            "     * @param Responder \\$responder The responder",
            "     */",
            "    public function __construct(Responder \\$responder)",
            "    {",
            "        \\$this->responder = \\$responder;",
            "    }",
            "",
            "    /**",
            "     * Action.",
            "     *",
            "     * @param ServerRequestInterface \\$request The request",
            "     * @param ResponseInterface \\$response The response",
            "     *",
            "     * @return ResponseInterface The response",
            "     */",
            "    public function __invoke(ServerRequestInterface \\$request, ResponseInterface \\$response): ResponseInterface",
            "    {",
            "        return \\$this->responder->withTemplate(\\$response, '${TM_DIRECTORY/^.+\\/(.*)$/${1:/downcase}/}/$0.twig');",
            "    }",
            "}",
            ""
        ],
        "description": "Slim4 skeleton action class"
    },

Generates file like:

<?php

namespace App\Action\Home;

use App\Responder\Responder;
use Psr\Http\Message\ResponseInterface;
use Psr\Http\Message\ServerRequestInterface;

/**
 * Action.
 */
final class HelloWorld
{
    /**
     * @var Responder
     */
    private $responder;

    /**
     * The constructor.
     *
     * @param Responder $responder The responder
     */
    public function __construct(Responder $responder)
    {
        $this->responder = $responder;
    }

    /**
     * Action.
     *
     * @param ServerRequestInterface $request The request
     * @param ResponseInterface $response The response
     *
     * @return ResponseInterface The response
     */
    public function __invoke(ServerRequestInterface $request, ResponseInterface $response): ResponseInterface
    {
        return $this->responder->withTemplate($response, 'home/.twig');
    }
}

Twig template snippet

    "slim4 skeleton Twig template": {
        "prefix": "extends",
        "body": [
            "{% extends \"layout/${1|layout-empty,layout|}.twig\" %}",
            "",
            "{% block css %}",
            "    {% webpack_entry_css '${TM_DIRECTORY/^.+\\/(.*)$/$1/}/$TM_FILENAME_BASE' %}",
            "{% endblock %}",
            "",
            "{% block js %}",
            "    {% webpack_entry_js '${TM_DIRECTORY/^.+\\/(.*)$/$1/}/$TM_FILENAME_BASE' %}",
            "{% endblock %}",
            "",
            "{% block content %}",
            "",
            "    <div class=\"container\">",
            "        $0",
            "    </div>",
            "",
            "{% endblock %}",
            ""
        ],
        "description": "slim4 skeleton Twig template"
    },

Generates file like:

{% extends "layout/layout-empty.twig" %}

{% block css %}
    {% webpack_entry_css 'home/hello-world' %}
{% endblock %}

{% block js %}
    {% webpack_entry_js 'home/hello-world' %}
{% endblock %}

{% block content %}

    <div class="container">
        
    </div>

{% endblock %}

Hi,

I set up the slim 4 framework following your ebook, but then ran into some issues with composer. After that I just took your slmi4-framwork from github and got it up and running. After that I followed the JWT part in your ebook but can't get it to work. I end up with a "Uncaught DI\DependencyException: Circular dependency detected while trying to resolve entry 'Slim\App'" error. Any help getting this solved would be greatly appreciated.

The error as i get it in postman when testing:

<br />
<b>Fatal error</b>:  Uncaught DI\DependencyException: Circular dependency detected while trying to resolve entry 'Slim\App' in /<project>/vendor/php-di/php-di/src/Container.php:384
Stack trace:
#0 /<project>/vendor/php-di/php-di/src/Container.php(139): DI\Container-&gt;resolveDefinition()
#1 /<project>/config/container.php(149): DI\Container-&gt;get()
#2 [internal function]: DI\Definition\Source\DefinitionFile-&gt;{closure}()
#3 /<project>/vendor/php-di/invoker/src/Invoker.php(74): call_user_func_array()
#4 /<project>/vendor/php-di/php-di/src/Definition/Resolver/FactoryResolver.php(80): Invoker\Invoker-&gt;call()
#5 /<project>/vendor/php-di/php-di/src/Definition/Resolver/ResolverDispatcher.php(71): DI\Definition\Resolver\FactoryResolver-&gt;resolve()
#6 /<project>/vendor/php-di/php-di/src/Container.php(390): DI\Definition\Resolver\ResolverDispatcher-&gt;resolve()
#7 /<project>/vendor/php-di/php-di/src/Container.php(139): DI\Container-&gt;resolveDefinition()
#8 /<project>/vendor/slim/slim/Slim/Factory/AppFactory.php(109): DI\Container-&gt;get()
#9 /<project>/config/container.php(37): Slim\Factory\AppFactory::createFromContainer()
#10 [internal function]: DI\Definition\Source\DefinitionFile-&gt;{closure}()
#11 /<project>/vendor/php-di/invoker/src/Invoker.php(74): call_user_func_array()
#12 /<project>/vendor/php-di/php-di/src/Definition/Resolver/FactoryResolver.php(80): Invoker\Invoker-&gt;call()
#13 /<project>/vendor/php-di/php-di/src/Definition/Resolver/ResolverDispatcher.php(71): DI\Definition\Resolver\FactoryResolver-&gt;resolve()
#14 /<project>/vendor/php-di/php-di/src/Container.php(390): DI\Definition\Resolver\ResolverDispatcher-&gt;resolve()
#15 /<project>/vendor/php-di/php-di/src/Container.php(139): DI\Container-&gt;resolveDefinition()
#16 /<project>/config/bootstrap.php(12): DI\Container-&gt;get()
#17 /<project>/public/index.php(6): require('...')
#18 {main}
  thrown in
<b>/<project>/vendor/php-di/php-di/src/Container.php</b> on line
<b>384</b>
<br />

contents of config/container.php:

<?php

use App\Routing\JwtAuth;
use Lcobucci\JWT\Configuration;
use Lcobucci\JWT\Signer\Rsa\Sha256;
use Lcobucci\JWT\Signer\Key\InMemory;
use App\Factory\LoggerFactory;
use App\Handler\DefaultErrorHandler;
use Cake\Database\Connection;
use Nyholm\Psr7\Factory\Psr17Factory;
use Psr\Container\ContainerInterface;
use Psr\Http\Message\ResponseFactoryInterface;
use Psr\Http\Message\ServerRequestFactoryInterface;
use Psr\Http\Message\StreamFactoryInterface;
use Psr\Http\Message\UploadedFileFactoryInterface;
use Psr\Http\Message\UriFactoryInterface;
use Selective\BasePath\BasePathMiddleware;
use Selective\Validation\Encoder\JsonEncoder;
use Selective\Validation\Middleware\ValidationExceptionMiddleware;
use Selective\Validation\Transformer\ErrorDetailsResultTransformer;
use Slim\App;
use Slim\Factory\AppFactory;
use Slim\Interfaces\RouteParserInterface;
use Slim\Middleware\ErrorMiddleware;
use Slim\Views\PhpRenderer;
use Symfony\Component\Console\Application;
use Symfony\Component\Console\Input\InputOption;
use Tuupola\Middleware\HttpBasicAuthentication;

return [
    // Application settings
    'settings' => function () {
        return require __DIR__ . '/settings.php';
    },

    App::class => function (ContainerInterface $container) {
        $app = AppFactory::createFromContainer($container);

        // Register routes
        (require __DIR__ . '/routes.php')($app);

        // Register middleware
        (require __DIR__ . '/middleware.php')($app);

        return $app;
    },

    // HTTP factories
    ResponseFactoryInterface::class => function (ContainerInterface $container) {
        return $container->get(Psr17Factory::class);
    },

    ServerRequestFactoryInterface::class => function (ContainerInterface $container) {
        return $container->get(Psr17Factory::class);
    },

    StreamFactoryInterface::class => function (ContainerInterface $container) {
        return $container->get(Psr17Factory::class);
    },

    UploadedFileFactoryInterface::class => function (ContainerInterface $container) {
        return $container->get(Psr17Factory::class);
    },

    UriFactoryInterface::class => function (ContainerInterface $container) {
        return $container->get(Psr17Factory::class);
    },

    // The Slim RouterParser
    RouteParserInterface::class => function (ContainerInterface $container) {
        return $container->get(App::class)->getRouteCollector()->getRouteParser();
    },

    // The logger factory
    LoggerFactory::class => function (ContainerInterface $container) {
        return new LoggerFactory($container->get('settings')['logger']);
    },

    BasePathMiddleware::class => function (ContainerInterface $container) {
        return new BasePathMiddleware($container->get(App::class));
    },

    // Database connection
    Connection::class => function (ContainerInterface $container) {
        return new Connection($container->get('settings')['db']);
    },

    PDO::class => function (ContainerInterface $container) {
        $db = $container->get(Connection::class);
        $driver = $db->getDriver();
        $driver->connect();

        return $driver->getConnection();
    },

    ValidationExceptionMiddleware::class => function (ContainerInterface $container) {
        return new ValidationExceptionMiddleware(
            $container->get(ResponseFactoryInterface::class),
            new ErrorDetailsResultTransformer(),
            new JsonEncoder()
        );
    },

    ErrorMiddleware::class => function (ContainerInterface $container) {
        $settings = $container->get('settings')['error'];
        $app = $container->get(App::class);

        $logger = $container->get(LoggerFactory::class)
            ->addFileHandler('error.log')
            ->createLogger();

        $errorMiddleware = new ErrorMiddleware(
            $app->getCallableResolver(),
            $app->getResponseFactory(),
            (bool)$settings['display_error_details'],
            (bool)$settings['log_errors'],
            (bool)$settings['log_error_details'],
            $logger
        );

        $errorMiddleware->setDefaultErrorHandler($container->get(DefaultErrorHandler::class));

        return $errorMiddleware;
    },

    Application::class => function (ContainerInterface $container) {
        $application = new Application();

        $application->getDefinition()->addOption(
            new InputOption('--env', '-e', InputOption::VALUE_REQUIRED, 'The Environment name.', 'development')
        );

        foreach ($container->get('settings')['commands'] as $class) {
            $application->add($container->get($class));
        }

        return $application;
    },

    PhpRenderer::class => function (ContainerInterface $container) {
        return new PhpRenderer($container->get('settings')['template']);
    },

    HttpBasicAuthentication::class => function (ContainerInterface $container) {
        return new HttpBasicAuthentication($container->get('settings')['api_auth']);
    },

    ResponseFactoryInterface::class => function (ContainerInterface $container) {
        return $container->get(App::class)->getResponseFactory();
    },

    JwtAuth::class => function (ContainerInterface $container) {
        $configuration = $container->get(Configuration::class);
        $jwtSettings = $container->get('settings')['jwt'];
        $issuer = (string)$jwtSettings['issuer'];
        $lifetime = (int)$jwtSettings['lifetime'];

        return new JwtAuth($configuration, $issuer, $lifetime);
    },

    Configuration::class => function (ContainerInterface $container) {
        $jwtSettings = $container->get('settings')['jwt'];

        $privateKey = (string)$jwtSettings['private_key'];
        $publicKey = (string)$jwtSettings['public_key'];
            
        // Asymmetric algorithms use a private key for signature creation
        // and a public key for verification
        return Configuration::forAsymmetricSigner(
            new Sha256(),
            InMemory::plainText($privateKey),
            InMemory::plainText($publicKey)
        );
    },
    
];

Small refactoring.

It seems easier to expect RouteParserInterface as constructor argument than retrieve it with RouteContext::fromRequest every time.

I'm not sure about performance, but all urls has been computed correctly.

I guess fullUrlFor will throw exception when $this->request is null anyway.