GeneratorCommand — eigen make: commando's implementeren

Wat is GeneratorCommand

Illuminate\Console\GeneratorCommand is de abstracte basisklasse voor alle codegeneratiecommando’s van Laravel. make:model, make:controller, make:request en dergelijke extenden allemaal deze klasse. Als je pakket een eigen make:xxx commando aanbiedt, hoeven gebruikers klassen niet meer handmatig aan te maken: ze voeren gewoon iets als php artisan make:handler OrderHandler uit en er wordt een bestand met de juiste namespace gegenereerd.

GeneratorCommand staat nauwelijks in de officiële documentatie; je begrijpt hem pas als je de broncode van het framework zelf leest. Een typisch gevorderd onderwerp.

Minimale implementatie

Een klasse die GeneratorCommand extendt, hoeft alleen de methode getStub() te implementeren. De overige properties zijn optioneel, maar in de praktijk stel je het volgende in.

Lid	Soort	Rol
`$name`	Property	Naam van het commando (bijv. `make:handler`)
`$description`	Property	Beschrijving van het commando
`$type`	Property	Typenaam van het gegenereerde artefact; wordt gebruikt in het succesbericht (bijv. `Handler`)
`getStub()`	Methode (verplicht)	Geeft het pad naar het stub-bestand terug
`getDefaultNamespace()`	Methode	Bepaalt de standaard-namespace van het gegenereerde bestand

Hier een voorbeeld van de implementatie van een make:handler commando.

<?php

namespace Vendor\Package\Console\Commands;

use Illuminate\Console\GeneratorCommand;

class HandlerMakeCommand extends GeneratorCommand
{
    protected $name = 'make:handler';

    protected $description = 'Create a new handler class';

    protected $type = 'Handler';

    protected function getStub(): string
    {
        return __DIR__.'/stubs/handler.stub';
    }

    protected function getDefaultNamespace($rootNamespace): string
    {
        return $rootNamespace.'\Handlers';
    }
}

Met getDefaultNamespace() ingesteld wordt bij het uitvoeren van php artisan make:handler OrderHandler de klasse App\Handlers\OrderHandler gegenereerd in app/Handlers/OrderHandler.php.

Een stub-bestand maken

Plaats een stub-bestand op het pad dat getStub() teruggeeft. Een stub is een PHP-bestand dat als template dient; de placeholders worden vervangen door de namespace en de klassenaam.

src

Console

Commands

HandlerMakeCommand.php

stubs

handler.stub

Voorbeeld van een stub-bestand:

handler.stub

<?php

namespace {{ namespace }};

class {{ class }}
{
    public function handle(): void
    {
        //
    }
}

GeneratorCommand vervangt automatisch de volgende placeholders in de stub.

Placeholder	Vervangen door	Alternatieve notatie
`{{ namespace }}`	Namespace van de gegenereerde klasse	`DummyNamespace`
`{{ class }}`	Naam van de gegenereerde klasse	`DummyClass`
`{{ rootNamespace }}`	Root-namespace van de app	`DummyRootNamespace`

{{ namespace }} en DummyNamespace geven allebei hetzelfde resultaat. De ingebouwde stubs van Laravel bevatten beide vormen, maar voor nieuwe stubs wordt de vorm {{ namespace }} aanbevolen.

Aanpasbare stubs mogelijk maken

Om gebruikers de mogelijkheid te geven stubs te overschrijven, gebruik je het resolveStubPath()-patroon. Publiceer eerst de stubs in de boot() van je service provider.

public function boot(): void
{
    if ($this->app->runningInConsole()) {
        $this->publishes([
            __DIR__.'/../Console/Commands/stubs' => base_path('stubs'),
        ], 'stubs');
    }
}

Laat vervolgens getStub() voorrang geven aan de door de gebruiker aangepaste stub.

protected function getStub(): string
{
    return $this->resolveStubPath('/stubs/handler.stub');
}

protected function resolveStubPath(string $stub): string
{
    return file_exists($customPath = $this->laravel->basePath(trim($stub, '/')))
        ? $customPath
        : __DIR__.$stub;
}

Gebruikers die php artisan vendor:publish --tag=stubs uitvoeren, kunnen de template aanpassen door stubs/handler.stub in de projectroot te bewerken.

resolveStubPath() is een patroon dat ook in Laravels ingebouwde RequestMakeCommand wordt gebruikt. Neem dit patroon over als je een pakket publiceert.

Registreren in de service provider

Commando’s registreer je in de boot()-methode van de service provider. Door te controleren met runningInConsole() voorkom je onnodig laden bij webrequests.

<?php

namespace Vendor\Package;

use Illuminate\Support\ServiceProvider;
use Vendor\Package\Console\Commands\HandlerMakeCommand;

class PackageServiceProvider extends ServiceProvider
{
    public function boot(): void
    {
        if ($this->app->runningInConsole()) {
            $this->commands([
                HandlerMakeCommand::class,
            ]);

            $this->publishes([
                __DIR__.'/../Console/Commands/stubs' => base_path('stubs'),
            ], 'stubs');
        }
    }
}

Als je extra.laravel instelt in de composer.json van je pakket, hoeven gebruikers de service provider niet handmatig te registreren.

"extra": {
    "laravel": {
        "providers": [
            "Vendor\\Package\\PackageServiceProvider"
        ]
    }
}

Toepassingen

Enkele use cases waarin GeneratorCommand goed van pas komt.

Uitgebreide form requests

Een commando dat Requests genereert die extenden van een eigen basisklasse met authenticatiechecks of aangepaste validatielogica. Laat getDefaultNamespace() App\Http\Requests teruggeven.

DTO-generator

Een commando dat de boilerplate voor Data Transfer Objects genereert. Voorzie een stub met readonly properties en een from()-factorymethode.

Action-klassen

Een commando dat Action-klassen met één verantwoordelijkheid genereert. Genereert klassen met een execute()-methode in de namespace App\Actions.

Livewire gebruikt hetzelfde mechanisme

Het commando make:livewire is geïmplementeerd in de klasse MakeCommand, die GeneratorCommand extendt. Om tegelijk twee bestanden te genereren — een componentklasse en een Blade-view — wordt handle() overschreven.

Testen

Met Orchestra Testbench test je dat het commando de bestanden correct genereert.

<?php

namespace Tests\Feature\Console;

use Illuminate\Support\Facades\File;
use Orchestra\Testbench\TestCase;
use Vendor\Package\PackageServiceProvider;

class HandlerMakeCommandTest extends TestCase
{
    protected function getPackageProviders($app): array
    {
        return [PackageServiceProvider::class];
    }

    protected function tearDown(): void
    {
        File::deleteDirectory(app_path('Handlers'));

        parent::tearDown();
    }

    public function test_make_handler_creates_file(): void
    {
        $path = app_path('Handlers/OrderHandler.php');

        $this->artisan('make:handler', ['name' => 'OrderHandler'])
            ->assertSuccessful();

        $this->assertFileExists($path);
        $this->assertStringContainsString('namespace App\Handlers;', File::get($path));
        $this->assertStringContainsString('class OrderHandler', File::get($path));
    }

    public function test_make_handler_does_not_overwrite_existing_file(): void
    {
        $path = app_path('Handlers/OrderHandler.php');
        File::ensureDirectoryExists(dirname($path));
        File::put($path, '<?php // existing');

        $this->artisan('make:handler', ['name' => 'OrderHandler'])
            ->assertFailed();
    }
}

Generatorcommando’s schrijven naar het echte bestandssysteem. Ruim altijd op in tearDown(). Die wordt ook betrouwbaar uitgevoerd als een test halverwege faalt.

Gerelateerde pagina’s

Laravel-pakketontwikkeling

Bekijk de basis van pakketontwikkeling met service providers.

Laravel-pakketten testen met Orchestra Testbench

Bekijk hoe je een basis opzet voor het testen van pakketten.

Source: Illuminate\Console\GeneratorCommand, Illuminate\Foundation\Console\RequestMakeCommand

AI-ontwikkeling

Design patterns

Package-ontwikkeling

Applicatiestructuur

Nieuwe functies in Laravel 13

Eloquent in detail

Validatie-uitbreidingen

Authenticatie uitbreiden

Beveiliging

Queues

Testen

GeneratorCommand — eigen make: commando's implementeren

Wat is GeneratorCommand

Minimale implementatie

Een stub-bestand maken

Aanpasbare stubs mogelijk maken

Registreren in de service provider

Toepassingen

Testen

Gerelateerde pagina’s

Laravel-pakketontwikkeling

Laravel-pakketten testen met Orchestra Testbench

​Wat is GeneratorCommand

​Minimale implementatie

​Een stub-bestand maken

​Aanpasbare stubs mogelijk maken

​Registreren in de service provider

​Toepassingen

​Testen

​Gerelateerde pagina’s

Laravel-pakketontwikkeling

Laravel-pakketten testen met Orchestra Testbench

Wat is GeneratorCommand

Minimale implementatie

Een stub-bestand maken

Aanpasbare stubs mogelijk maken

Registreren in de service provider

Toepassingen

Testen

Gerelateerde pagina’s