php slim skeleton

Esqueleto del marco Slim 4 basado en eventos

---

Un esqueleto de marco Slim 4 basado en eventos utilizando AMQP y CQRS

Instalación

Perfil de instalación predeterminado

El perfil de instalación predeterminado no tiene ejemplos. Debería usar este perfil si sabe lo que pasa y quiere comenzar con una pizarra limpia.

 > 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 de instalación completo

El perfil de instalación completo tiene un ejemplo de trabajo 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

Algunos ejemplos

Registrando una nueva ruta

 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 ;
    }
}

Dirígete a config/routes.php y agregue una ruta para su Solicitud de Handler:

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

Documentación completa

Comandos de consola

La aplicación de la consola utiliza el componente de la consola Symfony para aprovechar la funcionalidad CLI.

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

Documentación completa

Comandos de dominio y manejadores de comandos

El esqueleto le permite usar comandos y controladores de comandos para realizar acciones. Estos 2 siempre vienen en pares, al crear un nuevo comando en el modelo de escritura, también se debe crear un controlador de comandos correspondiente.

Creando un nuevo comando

 namespace App  Domain  WriteModel  User  CreateUser ;

class CreateUser extends DomainCommand
{
 
}

Creación del controlador de comandos correspondiente

 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.
    }
}

Documentación completa

Evidente

La idea de este proyecto es que todo está, o puede estar impulsado por eventos. El abastecimiento de eventos no se proporciona de manera predeterminada.

Crea un nuevo evento

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

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

Grabe el 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 ;
    }
}

Publicar el evento

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

Escucha el evento

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

Documentación completa

Procesamiento de asíncrono de comandos con conejo

La implementación de AMQP elegida para este proyecto es RabbitMQ, pero se puede cambiar fácilmente a la solución AMQP de Amazon.

Registrando nuevas colas

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

Comandos de colas

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

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

Consumiendo tu cola

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

Documentación completa

Migraciones de bases de datos

Para administrar migraciones de bases de datos, se utiliza el paquete de doctrina/migraciones.

#[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 ,
    ) {
    }

    // ...
}

Puede hacer que la doctrina genere una migración para usted comparando el estado actual del esquema de su base de datos con la información de mapeo que se define utilizando el ORM y luego ejecuta esa migración.

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

Documentación completa

Motor de plantilla

El motor de plantilla elegido para este proyecto es Twig y se puede usar para representar cualquier cosa relacionada con HTML.

Crear una plantilla

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

Representar la plantilla

 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 ;
    }
}

Documentación completa

Documentación

Obtenga más información en estos enlaces:

• Documentación del esqueleto
• Marco delgado
• Php-di
• Comandos de la consola Symfony
• Migraciones de doctrina
• Ramita

Proyectos que usan este esqueleto

• API pública de la Asociación Mundial de Cubos no oficiales (WCA)
• Base de datos de tarjetas Pokémon recién generadas usando GPT y difusión estable
• Una aplicación PHP que genera tarjetas Pokémon usando GPT y difusión estable
• Genere imágenes 3D completas de un cubo Rubiks

Que contribuye

Consulte contribuyendo para obtener más detalles.