php slim skeleton Download - php slim skeleton Source Code Download

Esqueleto de estrutura Slim 4 Slim 4, acionado por eventos

Um esqueleto de estrutura Slim 4, orientado a eventos, usando o AMQP e o CQRS

Instalação

Perfil de instalação padrão

O perfil de instalação padrão não tem exemplos. Você deve usar esse perfil se souber o que está acontecendo e deseja começar com uma lousa limpa.

 > composer create-project robiningelbrecht/php-slim-skeleton [app-name] --no-install --ignore-platform-reqs --stability=dev
# Build docker containers
> docker-compose up -d --build
# Install dependencies
> docker-compose run --rm php-cli composer install

Perfil completo de instalação

O perfil completo de instalação tem um exemplo de trabalho completo.

 > composer create-project robiningelbrecht/php-slim-skeleton:dev-master-with-examples [app-name] --no-install --ignore-platform-reqs --stability=dev
# Build docker containers
> docker-compose up -d --build
# Install dependencies
> docker-compose run --rm php-cli composer install
# Initialize example
> docker-compose run --rm php-cli composer example:init
# Start consuming the voting example queue
> docker-compose run --rm php-cli bin/console app:amqp:consume add-vote-command-queue

Alguns exemplos

Registrando uma nova rota

 namespace App  Controller ;

class UserOverviewRequestHandler
{
    public function __construct (
        private readonly UserOverviewRepository $ userOverviewRepository ,
    ) {
    }

    public function handle (
        ServerRequestInterface $ request ,
        ResponseInterface $ response ): ResponseInterface
    {
        $ users = $ this -> userOverviewRepository -> findonyBy ( /*...*/ );
        $ response -> getBody ()-> write ( /*...*/ );

        return $ response ;
    }
}

Vá para config/routes.php e adicione uma rota para o seu requestHandler:

 return function ( App $ app ) {
    // Set default route strategy.
    $ routeCollector = $ app -> getRouteCollector ();
    $ routeCollector -> setDefaultInvocationStrategy ( new RequestResponseArgs ());
    
    $ app -> get ( ' /user/overview ' , UserOverviewRequestHandler::class. ' :handle ' );
};

Documentação completa

Comandos de console

O aplicativo de console usa o componente do Symfony Console para aproveitar a funcionalidade da CLI.

#[AsCommand(name: ' app:user:create ' )]
class CreateUserConsoleCommand extends Command
{
    protected function execute ( InputInterface $ input , OutputInterface $ output ): int
    {
        // ...
        return Command:: SUCCESS ;
    }
}

Documentação completa

Comandos de domínio e manipuladores de comando

O esqueleto permite que você use comandos e manipuladores de comando para executar ações. Esses 2 sempre vêm em pares, ao criar um novo comando no modelo de gravação, um manipulador de comando correspondente também deve ser criado.

Criando um novo comando

 namespace App  Domain  WriteModel  User  CreateUser ;

class CreateUser extends DomainCommand
{
 
}

Criando o manipulador de comando correspondente

 namespace App  Domain  WriteModel  User  CreateUser ;

#[AsCommandHandler]
class CreateUserCommandHandler implements CommandHandler
{
    public function __construct (
    ) {
    }

    public function handle ( DomainCommand $ command ): void
    {
        assert ( $ command instanceof CreateUser);

        // Do stuff.
    }
}

Documentação completa

Evento

A idéia deste projeto é que tudo é, ou pode ser orientado a eventos. O fornecimento de eventos não é fornecido por padrão.

Crie um novo evento

 class UserWasCreated extends DomainEvent
{
    public function __construct (
        private UserId $ userId ,
    ) {
    }

    public function getUserId (): UserId
    {
        return $ this -> userId ;
    }
}

Registre o evento

 class User extends AggregateRoot
{
    private function __construct (
       private UserId $ userId ,
    ) {
    }

    public static function create (
        UserId $ userId ,
    ): self {
        $ user = new self ( $ userId );
        $ user -> recordThat ( new UserWasCreated ( $ userId ));

        return $ user ;
    }
}

Publique o evento

 class UserRepository extends DbalAggregateRootRepository
{
    public function add ( User $ user ): void
    {
        $ this -> connection -> insert ( /*...*/ );
        $ this -> publishEvents ( $ user -> getRecordedEvents ());
    }
}

Ouça o evento

#[AsEventListener(type: EventListenerType:: PROCESS_MANAGER )]
class UserNotificationManager extends ConventionBasedEventListener
{
   
    public function reactToUserWasCreated ( UserWasCreated $ event ): void
    {
        // Send out some notifications.
    }
}

Documentação completa

Processamento assíncrono de comandos com RabbitMQ

A implementação do AMQP escolhida para este projeto é o RabbitMQ, mas pode ser facilmente alterado para, por exemplo, a solução AMQP da Amazon.

Registrando novas filas

#[AsEventListener(type: EventListenerType:: PROCESS_MANAGER )]
class UserCommandQueue extends CommandQueue
{
}

Comandos de fila

 class YourService
{
    public function __construct (
        private readonly UserCommandQueue $ userCommandQueue
    ) {
    }

    public function aMethod (): void
    {
        $ this -> userCommandQueue -> queue ( new CreateUser ( /*...*/ ));
    }
}

Consumindo sua fila

 > docker-compose run --rm php-cli bin/console app:amqp:consume user-command-queue

Documentação completa

Migrações de banco de dados

Para gerenciar as migrações de banco de dados, o pacote de doutrina/migração é usado.

#[Entity]
class User extends AggregateRoot
{
    private function __construct (
        #[Id, Column(type: ' string ' , unique: true , nullable: false )]
        private readonly UserId $ userId ,
        #[Column(type: ' string ' , nullable: false )]
        private readonly Name $ name ,
    ) {
    }

    // ...
}

Você pode ter a doutrina gerar uma migração para você comparando o estado atual do seu esquema de banco de dados com as informações de mapeamento definidas usando o ORM e executando essa migração.

 > docker-compose run --rm php-cli vendor/bin/doctrine-migrations diff
> docker-compose run --rm php-cli vendor/bin/doctrine-migrations migrate

Documentação completa

Motor de modelos

O mecanismo de modelo de escolha para este projeto é o Twig e pode ser usado para renderizar qualquer coisa relacionada ao HTML.

Crie um modelo

< h1 >Users</ h1 >
< ul >
    {% for user in users %}
        < li >{{ user . username | e }}</ li >
    {% endfor %}
</ ul >

Renderizar o modelo

 class UserOverviewRequestHandler
{
    public function __construct (
        private readonly Environment $ twig ,
    ) {
    }

    public function handle (
        ServerRequestInterface $ request ,
        ResponseInterface $ response ): ResponseInterface
    {
        $ template = $ this -> twig -> load ( ' users.html.twig ' );
        $ response -> getBody ()-> write ( $ template -> render ( /*...*/ ));

        return $ response ;
    }
}