getsolaris/laravel-make-service
A Laravel package that adds Artisan commands for generating service classes, helping you organize business logic into dedicated services with a clean, customizable structure.
Architecture fit: getsolaris/laravel-make-service is a developer-tooling package, not a runtime library. It contributes a single Artisan generator (make:service) plus publishable stubs, so it sits entirely in the scaffolding layer of our Laravel codebase and adds zero surface area to the production request lifecycle. The architectural question it raises is not "does it fit the runtime" but "does its opinionated service-class shape match our service layer conventions" — constructor injection, interface binding, readonly/final modifiers, strict types, and namespace depth. That is a convention decision, not an infrastructure one.
Integration feasibility: Very high. Install is composer require --dev, and the package requires no service provider bootstrapping, no migrations, no config files unless we choose to publish stubs. A single engineer can validate it against one module in an afternoon. The main feasibility work is comparing the default stub output against our existing service classes.
Technical risk: Low, with one caveat. Because it is dev-only and generates source we then own and review in PRs, a defect in the generator cannot reach production at runtime — the failure mode is a bad scaffold that code review catches. The caveat is supply-chain and maintenance risk: this is a single-maintainer package whose Laravel compatibility updates appear to arrive via automated Laravel Shift pull requests. v1.1.4 being a compatibility-only patch is a positive signal (the maintainer is responsive to framework releases) but also confirms the package is on life support rather than active feature development. If the maintainer stops merging Shift PRs, we are stuck pinning a framework version or forking.
Key questions:
make:service Billing/InvoiceService) so it matches our modular structure?Stack fit: Designed for Laravel's Artisan console and Composer autoloading; fits any Laravel application regardless of frontend or persistence choices. v1.1.4's contribution is extending the supported framework ceiling to Laravel 13.x — meaning we can adopt it on our current major and carry it forward through the next upgrade without swapping tooling. Confirm the package's PHP floor is at or below our runtime so we are not forced into an early PHP bump.
Migration path: There is no migration in the data sense. The path is: (1) add as a require-dev dependency on a branch; (2) run the generator in a scratch directory and diff the output against two or three of our hand-written service classes; (3) publish the stubs and edit them to encode our house conventions; (4) commit the customized stubs so every future scaffold is consistent by default. Steps 1–2 are reversible in minutes; step 4 is where the durable value and the durable commitment both live.
Compatibility: The package now spans the Laravel 13.x line. Two things to verify rather than assume: the exact constraint string in composer.json (a loose ^10|^11|^12|^13 is fine; a hard pin to a recent minor is a red flag), and whether the Laravel 13 support required any stub changes. For us, the practical compatibility question is whether our CI matrix and lockfile allow a dev dependency that declares support for a framework major we have not yet adopted — usually yes, but worth a one-line check before merge.
Sequencing: Pilot in a single squad or module first, with a named owner. Publish and review customized stubs as a standalone PR so the convention change is visible and reviewable on its own. Only after that PR lands should other teams be pointed at the generator; a shared stub template that ships before it is agreed creates churn across every module at once. Treat the framework-version bump implied by v1.1.4 as a separate, later step tied to whatever Laravel 13 upgrade work already exists on the roadmap — do not let a code-generator patch pull the upgrade forward.
Maintenance: Near zero in steady state. Dev-only dependency, no config drift, no migrations. The recurring cost is stub hygiene: whenever our service conventions change, the committed stubs must change with them, and that ownership needs a named team rather than diffusing across squads. Budget a small review each Laravel major to confirm the generator still emits valid code.
Support: The weakest dimension. Single maintainer, low bus factor, and patch releases that are compatibility maintenance rather than active development. Support for our engineers will realistically come from the team that owns the stubs, not upstream. Mitigate by keeping the customization confined to published stubs — if the package is abandoned, we replace the generator command with an in-house Artisan command and keep the stubs untouched. That exit costs an afternoon, and it is worth writing that down now.
Scaling: Effectively unlimited — the package does no work at runtime and its cost does not grow with request volume, data size, or team size. The only scaling concern is organizational: the more teams adopt it, the more valuable a single agreed stub becomes, and the more disruptive it is to change later. Standardize early or not at all.
Failure modes:
Ramp-up: Minimal — a single Artisan invocation, learnable in under ten minutes with no training material required beyond a stub README. The real ramp-up is social: engineers need to know the stubs are the source of truth and that changing conventions means changing the stub, not hand-editing one more class. That is a paragraph in the team's conventions doc, not a training program.
How can I help you explore Laravel packages today?