PHPackages eliezer/chapolim - PHPackages - PHPackages [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register) 1. [Directory](/) 2. / 3. [Framework](/categories/framework) 4. / 5. eliezer/chapolim ActiveLibrary[Framework](/categories/framework) eliezer/chapolim ================ A simple package to manage the creation of a structure composed of the service and repository layers in a Laravel application 552.4k1PHP Since Aug 16Pushed 4y ago1 watchersCompare [ Source](https://github.com/12161003677/chapolim)[ Packagist](https://packagist.org/packages/eliezer/chapolim)[ RSS](/packages/eliezer-chapolim/feed)WikiDiscussions main Synced 1mo ago READMEChangelogDependenciesVersions (2)Used By (0) [![NOLOCK](https://camo.githubusercontent.com/d791de4fe9582a864c83c9299d8d93adab800ba8d821f6e2abb1936902f41e77/68747470733a2f2f692e696d6775722e636f6d2f32556779766b422e706e67)](https://nolock.com.br/) Chapolim -------- [](#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 ------- [](#sumário) 1. [**\# Laravel**](#laravel) 2. [**\# Artisan**](#artisan) 3. [**\# Reposittory Pattern**](#reposittory-pattern) 4. [**\# Service Layer**](#service-layer) 5. [**\# Setup**](#setup) 6. [**\# Uso**](#uso) - [\# --module](#module) - [\# chapolim:make-repository](#chapolimmake-repository) - [\# chapolim:make-service](#chapolimmake-service) - [\# chapolim:make-model](#chapolimmake-model) - [\# chapolim:make-controller](#chapolimmake-controller) - [\# chapolim:make](#chapolimmake) Laravel ------- [](#laravel) [Sumário](#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](https://laravel.com/docs/8.x#meet-laravel) Artisan ------- [](#artisan) [Sumário](#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](https://laravel.com/docs/8.x/artisan#introduction) Para ver uma lista de todos os comandos Artisan disponíveis, você pode usar o listcomando: ``` php artisan list ``` Reposittory Pattern ------------------- [](#reposittory-pattern) [Sumário](#sumário) [Reposittory Pattern](https://asperbrothers.com/blog/implement-repository-pattern-in-laravel/) é 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 ------------- [](#service-layer) [Sumário](#sumário) A Camada de Serviço ou [Service Layer](https://luis-barros-nobrega.medium.com/laravel-service-layer-with-dtos-and-validators-2c6303899a57) é 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 ----- [](#setup) [Sumário](#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 --- [](#uso) [Sumário](#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 [](#--module) [Sumário](#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 [](#chapolimmake-repository) [Sumário](#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 [](#chapolimmake-service) [Sumário](#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 [](#chapolimmake-model) [Sumário](#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 [](#chapolimmake-controller) [Sumário](#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 [](#chapolimmake) [Sumário](#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. ### Health Score 25 — LowBetter than 37% of packages Maintenance20 Infrequent updates — may be unmaintained Popularity32 Limited adoption so far Community8 Small or concentrated contributor base Maturity30 Early-stage or recently created project Bus Factor1 Top contributor holds 100% of commits — single point of failure How is this calculated?**Maintenance (25%)** — Last commit recency, latest release date, and issue-to-star ratio. Uses a 2-year decay window. **Popularity (30%)** — Total and monthly downloads, GitHub stars, and forks. Logarithmic scaling prevents top-heavy scores. **Community (15%)** — Contributors, dependents, forks, watchers, and maintainers. Measures real ecosystem engagement. **Maturity (30%)** — Project age, version count, PHP version support, and release stability. ### Community Maintainers ![](https://www.gravatar.com/avatar/4ac0584489c0d58b569f89a7042cd59a6bb92789671c579af5a29776501119ee?d=identicon)[12161003677](/maintainers/12161003677) --- Top Contributors [![eliezer-alves](https://avatars.githubusercontent.com/u/23661672?v=4)](https://github.com/eliezer-alves "eliezer-alves (75 commits)") --- Tags artisancommandslaravelphprepository-patternservice-layer ### Embed Badge ![Health badge](/badges/eliezer-chapolim/health.svg) ``` [![Health](https://phpackages.com/badges/eliezer-chapolim/health.svg)](https://phpackages.com/packages/eliezer-chapolim) ``` ### Alternatives [laravel/telescope An elegant debug assistant for the Laravel framework. 5.2k67.8M190](/packages/laravel-telescope)[spiral/roadrunner RoadRunner: High-performance PHP application server and process manager written in Go and powered with plugins 8.4k12.2M84](/packages/spiral-roadrunner)[nolimits4web/swiper Most modern mobile touch slider and framework with hardware accelerated transitions 41.8k177.2k1](/packages/nolimits4web-swiper)[laravel/dusk Laravel Dusk provides simple end-to-end testing and browser automation. 1.9k36.7M255](/packages/laravel-dusk)[laravel/prompts Add beautiful and user-friendly forms to your command-line applications. 708181.8M590](/packages/laravel-prompts)[cakephp/chronos A simple API extension for DateTime. 1.4k47.7M119](/packages/cakephp-chronos) PHPackages © 2026 [Directory](/)[Categories](/categories)[Trending](/trending)[Changelog](/changelog)[Analyze](/analyze)