eliezer / chapolim
A simple package to manage the creation of a structure composed of the service and repository layers in a Laravel application
This package is auto-updated.
Last update: 2024-04-29 05:05:27 UTC
README
Chapolim
Este projeto tem como objetivo fornecer alguns comandos adicionais à interface de linha de comando do Laravel, o Artisan, para manipular a estrutura de um projeto que utiliza as camadas de Serviço e Reopositório: Service Layer / Repository Pattern. Dessa forma, é possível criar uma estrutura completa para gerenciar um modelo, criando e injetando as dependências das classes de todas as camadas: routes, Controllers, Service, Repository e Model com um único comando. Vale a pena dar uma conferida 😄
Sumário
Laravel
Sumário
Laravel é um framework de aplicação web com sintaxe expressiva e elegante. Uma estrutura da web fornece uma estrutura e um ponto de partida para a criação de seu aplicativo, permitindo que você se concentre na criação de algo incrível enquanto suamos nos detalhes. Documentação do Laravel
Artisan
Sumário
"Artisan é a interface de linha de comando incluída no Laravel. O Artisan existe na raiz do seu aplicativo como o artisanscript e fornece uma série de comandos úteis que podem ajudá-lo enquanto você constrói seu aplicativo." Documentação do Laravel
Para ver uma lista de todos os comandos Artisan disponíveis, você pode usar o listcomando:
php artisan list
Reposittory Pattern
Sumário
Reposittory Pattern é um padrão de projeto que visa adicionar uma camada de abstração entre a camada dos modelos (Models) e os controladores (Controllers) ou ainda da camada de serviço (Services). Dessa forma, cada Model possui uma classe Repository correspondente. Ademais, numa abordagem padrão essas classes ficam na pasta app/Repositories/Eloquent e são injetadas por meio de Interfaces, que se encontram em app/Repositories/Contracts.
Service Layer
Sumário
A Camada de Serviço ou Service Layer é um padrão de projeto que visa abstrair a lógica ou regra de nogócio da aplicação, que normalmente se encontra na camado dos controladores, para uma nova camada: a Camada de Serviço. Nesse contexto, em uma abordagem padrão cada controlador possui sua classe de serviço para quem delega as funções que normalmente deveria exercer. Dessa forma, os controladores se limitam a gerenciar o que entra por meio das rotas (requests) e o que será retornado a partir de então (responses). Assim, além de o projeto ficar mais estruturado é garantido também um desacoplamento da regra de negócio e o framework em uso, pois a regra de negócio estará em uma camada criada exclusivamente pelo desenvolvedor.
Setup
Sumário
Para utilizar esse litle package desenvolvido por um pocket edition developer basta instalar o pacote via composer, para isso execute o seguinte comando na raiz do seu projeto:
composer require eliezer/chapolim
Uso
Sumário
Uma vez devidamente instalado você terá acesso aos comandos php artisan chapolim ---, esses comandos serão listados juntamente com os outros comandos do Artisan ao exceutar:
php artisan
Os comandos chapolim serão listados da seguinte forma:
...
chapolim
chapolim:make Generates project scaffold with all layers
chapolim:make-controller Create a new controller class by injecting a service class
chapolim:make-model Create a new model class with table attribute and fillable attribute
chapolim:make-repository Create a new repository class
chapolim:make-service Create a new service class
...
Dessa forma segue a descrição de cada comando.
--module
Sumário
É normal que quando uma aplicação começa a crescer algumas reestruturações sejam feitas para que ela continue escalonável e organizadas. Nesse contexto, uma boa prática é a modularização do sistema, desacoplando funcionalidades e serviços em estruturas de pasta que chamamos de módulo. Nesse contexto, caso a sua aplicação esteje modularizada você nem sempre vai desejar criar suas classes dentro da /app. Dessa forma, a option --module serve para que suas classes sejam geradas no módulo especificado ao invés de serem criadas na /app e pode ser usada com qualquer comando abaixo.
chapolim:make-repository
Sumário
As classes geradas como o comando chapolim:make-repository serão criadas no diretório app/Repositories/Eloquent, esse diretório não existe por padrão, dessa forma ele será criado a primeira vez que for rodado o comando. Ainda assim, um outro diretório será criado app/Repositories/Contracts, esse diretório conterá as classes de interface das classes de repositório, pois estas nunca são injetadas diretamente. Dessa forma, o comando pode receber o argumento --orm que serve para definir a pasta onde serão criados as classes de repositório dentro app/Repositories, assim, ao contrário de ser geradas na pasta pdrão 'Eloquent' você poderá especificar o nome da pasta.
Ademais, a primeira vez o o comando chapolim:make-repository for rodado será feito um processo de scafolding onde, além de serem criados os diretórios supracitados, serão criadas as classes AbstractRepository (contendo todos os métodos padrões de uma classe de repositório a qual será estendida por todas as outras classes de repositório), a sua interface AbstractRepositoryInterface e finalmente a classe RepositoryServiceProvider, essa última será a classe responsável por informar à aplicação a relação entre as classes de repositório e suas interfaces, sendo que é por conta disso que será possível utilizar as classes por meio das suas interfaces e será criada em app/Providers.
Assim, toda vez que for criada uma nova classe de repositório será também criada a sua interfece e a relação entre as duas será provida à aplicação por meio da RepositoryServiceProvider, sendo que isto é feito varrendo o diretório app/Repositories/Eloquent e reescrevendo o arquivo com as classes presentes nesse diretório. Entrtanto, caso você defina uma outra pasta para as classes de repositório por meio da option --orm o arquivo RepositoryServiceProvider será atualizado e conterá somente as classes que existirem nessa nova pasta que foi definida. Ademais, é importante frizar que a classe RepositoryServiceProvider é automaticamente inserida em config/app.php mas pode ser que isso não aconteça, então é importante validar se ela se encontra no array de providers do arquivo config/app.php.
Segue os detalhes do comando:
Description: Create a new repository
Usage: chapolim:make-repository [options] [--]
Arguments:
name The name of the repository.
Options:
--module[=MODULE] The application module.
-m, --model[=MODEL] The model to be injected into the repository.
--orm[=ORM] Folder where the repository will be created - default Eloquent.
--force Force file creation.
chapolim:make-service
Sumário
As classes geradas como o comando chapolim:make-service serão criadas no diretório app/Services, esse diretório não existe por padrão, dessa forma ele será criado a primeira vez que for rodado o comando. Nesse contexto, a classe de serviço mais completa que você poderá gerar conterá os métodos de um crud padrão (index, store, show, update e destroy), sendo que cada método já estará pronto para uso pois já estará delegando a responsabilidade para a classe de repositório, isso será possível especificando as options --repository e --resource.
Segue os detalhes do comando:
Description: Create a new service
Usage: chapolim:make-service [options] [--]
Arguments:
name The name of the service.
Options:
--module[=MODULE] The application module.
-R, --repository[=REPOSITORY] The repository class to be injected into the service.
-r, --resource Generates a resource service class.
--force Force file creation.
chapolim:make-model
Sumário
Por padrão o Artisan já possui comandos para a criação dos modelos, no entanto nesses comandos não é possível a especificação do fillable da classe, ou seja, não é possível especificar as colunas da tabela cujo o modelo representa. Dessa forma, o chapolim possui um comando para gerar os modelos com essa propriedade: chapolim:make-model --fillable='username|email|password'. Dessa maneira, como você pode notar você pode especificar seu fillable por meio da option --fillable.
Segue os detalhes do comando:
Description: Create a new model class with table attribute and fillable attribute
Usage: chapolim:make-model [options] [--]
Arguments:
name The name of the model.
Options:
--module[=MODULE] The application module.
-F, --fillable[='column|column2'] The fillable attribute of the model.
--force Force file creation.
chapolim:make-controller
Sumário
Da mesma forma que para os modelos, o Artisan já possui comandos para a criação dos controladores, entretanto não existe nesses comandos a opção de injetar uma classe de serviço. Dessa forma, o chapolim possui um comando para gerar controladores com classes de serviço: chapolim:make-controller. Assim, as classes geradas como o comando chapolim:make-controller serão criadas no diretório app/Http/Controllers e já virão com uma classe de serviço injetada, sendo que o nome desta pode ser especificado por meio da option --service. Nesse contexto, caso a classe de serviço não for especificada será injetada uma seguindo o pdrão do nome do controlador. Ademais, é possível gerar automáticamente um grupo de rotas do controlador em app/routes/api.php sendo que para isto basta especificar a option --route.
Segue os detalhes do comando:
Description: Create a new controller class by injecting a service class
Usage: chapolim:make-controller [options] [--]
Arguments:
name The name of the controller.
Options:
--module[=MODULE] The application module.
-S, --service[=SERVICE] The service to be injected into the controller.
-r, --resource Generates a resource service class.
--route Generates a group of routes referring to the controller in app/routes/api.php.
--force Force file creation.
chapolim:make
Sumário
Finalmente chegamos ao principal comando do pacote: chapolim:make, com este comando é possível criar uma estrutura completa envolvendo todas as quatros camadas: Model, Repoditory, Service e Controller. Nesse contexto, o comando irá receber o argumento name que será a base para a geração das classes especificadas sendo que essas classes serão especificadas por meio das options. Assim, o chapolim irá simplismente executar os comandos já existentes para a criação das classes de cada camada. Dessa forma, vale ressaltar que se por acaso as options referentes às camadas não forem informadas será o mesmo que passar a option --all, ou seja, o chapolim irá criar as classes de todas as camadas. Dessa maneira o comando
php artisan chapolim:make Caneta --fillable='cor|marca|preco' --route -r
irá criar uma estrutura completa para o CRUD padrão de Canetas.
Segue os detalhes do comando:
Description: Generates project scaffold with all layers
Usage: chapolim:make [options] [--]
Arguments:
name The base name of the all classes
Options:
--module[=MODULE] The application module.
-m, --model Generates a model class.
-M, --migration Generates a migration class.
-c, --controller Generates a controller class.
-R, --repository Generates a repository class.
-S, --service Generates a service class.
-a, --all Generates the classes of all layers.
-r, --resource Generate a resource in controller and service classes
--route Generates a group of routes referring to controller resources in the api route file.
-F, --fillable[='column|column2'] The fillable attribute of the model.