Artisan-console - Knowledge of Laravel

Wat is Artisan

Artisan is de command-line interface (CLI) die bij Laravel wordt meegeleverd. Het bestaat als het artisan-script in de projectroot en biedt talloze commando’s die ontwikkeling en beheer efficiënter maken. Gebruik het list-commando om een overzicht van de beschikbare commando’s te bekijken.

php artisan list

Om te zien hoe je een commando gebruikt, zet je er help voor.

php artisan help migrate

Gebruik je Laravel Sail, gebruik dan sail artisan in plaats van php artisan. Het commando wordt dan uitgevoerd binnen de Docker-container.

./vendor/bin/sail artisan list

Tinker

Laravel Tinker is een REPL-omgeving waarmee je de hele applicatie — Eloquent-modellen, jobs, events en meer — interactief kunt bedienen vanaf de command line.

php artisan tinker

Na het starten kun je direct PHP-code uitvoeren.

// Een gebruiker ophalen en bekijken
>>> App\Models\User::find(1)
// Een record aanmaken met een factory
>>> App\Models\User::factory()->create()
// Een serviceklasse rechtstreeks aanroepen
>>> app(App\Services\OrderService::class)->process(1)

Tinker wijzigt data daadwerkelijk. Wees zeer voorzichtig met uitvoeren in productie. Het is vooral geschikt voor het testen en debuggen in lokale en staging-omgevingen.

Eigen commando’s maken

Een commando genereren

Met make:command genereer je een sjabloon voor een commandoklasse.

php artisan make:command ImportProducts

Er wordt een bestand app/Console/Commands/ImportProducts.php gegenereerd.

De basisstructuur van een commando

De gegenereerde commandoklasse heeft drie hoofdonderdelen: $signature, $description en handle().

<?php

namespace App\Console\Commands;

use Illuminate\Console\Command;

class ImportProducts extends Command
{
    /**
     * Definitie van de commandonaam, argumenten en opties
     */
    protected $signature = 'import:products';

    /**
     * Beschrijving van het commando (getoond in php artisan list)
     */
    protected $description = 'Importeert productdata uit een CSV';

    /**
     * De uitvoering van het commando
     */
    public function handle(): void
    {
        $this->info('Import wordt gestart...');
        // Schrijf hier je verwerking
        $this->info('Klaar.');
    }
}

In Laravel 13 kun je ook een schrijfwijze met PHP-attributen gebruiken.

use Illuminate\Console\Attributes\Description;
use Illuminate\Console\Attributes\Signature;

#[Signature('import:products')]
#[Description('Importeert productdata uit een CSV')]
class ImportProducts extends Command
{
    public function handle(): void
    {
        // ...
    }
}

Argumenten en opties definiëren

In $signature definieer je de commandonaam, argumenten en opties samen.

protected $signature = 'import:products
                        {file : Pad naar het te importeren CSV-bestand}
                        {--limit= : Maximaal aantal te importeren records}
                        {--dry-run : Niets opslaan in de DB (ter controle)}';

Notatie	Type	Beschrijving
`{file}`	Verplicht argument	Weglaten geeft een fout
`{file?}`	Optioneel argument	Bij weglaten `null`
`{file=products.csv}`	Argument met standaardwaarde	Bij weglaten wordt de standaardwaarde gebruikt
`{--queue}`	Flag-optie	`true` indien opgegeven, anders `false`
`{--limit=}`	Optie met waarde	Geef een waarde door zoals `--limit=100`
`{--limit=50}`	Optie met standaardwaarde	Bij weglaten `50`
`{--Q\|queue}`	Met shortcut	Ook op te geven als `-Q`

Argumenten en opties ophalen

In de handle()-methode haal je de waarden op met argument() en option().

public function handle(): void
{
    $file    = $this->argument('file');       // Argument ophalen
    $limit   = $this->option('limit');        // Optie ophalen
    $dryRun  = $this->option('dry-run');      // Flag-optie (bool)

    $this->info("Bestand: {$file}");

    if ($dryRun) {
        $this->warn('Dry-run-modus: opslaan in de DB wordt overgeslagen');
    }
}

`input()` — getypeerde accessors

Met de input()-methode kun je argumenten en opties van een commando ophalen via dezelfde getypeerde accessors als bij HTTP-requests.

use App\Enums\ReportType;

public function handle(): void
{
    // Argumenten en opties ophalen als CommandInput-instantie
    $from = $this->input()->date('from');
    $type = $this->input()->enum('type', ReportType::class);
    $limit = $this->input()->integer('limit');
}

Wil je alleen een specifieke naam ophalen, dan geef je de naam rechtstreeks door (er wordt gezocht in zowel argumenten als opties).

$queue = $this->input('queue', 'default');

Waar argument() en option() strings teruggeven, converteren de getypeerde accessors van input() naar het juiste type. Handig als je datums, getallen of enums typesafe wilt behandelen.

Interactie met de gebruiker

Berichten uitvoeren

Er zijn methoden beschikbaar om gekleurde berichten naar de console te schrijven.

$this->info('Verwerking succesvol afgerond');    // groen
$this->warn('Deze actie kan niet ongedaan worden gemaakt');    // geel
$this->error('Er is een fout opgetreden');       // rood
$this->line('Gewone tekst');             // zonder kleur
$this->comment('Aanvullende info');               // lichtgrijs

Vragen stellen aan de gebruiker

Je kunt interactief invoer van de gebruiker ontvangen.

// Tekstinvoer
$name = $this->ask('Voer de naam van de contactpersoon in');

// Met standaardwaarde
$env = $this->ask('Kies de uitvoeringsomgeving', 'production');

// Geheime informatie zoals wachtwoorden (invoer wordt niet op het scherm getoond)
$password = $this->secret('Voer de API-sleutel in');

// Ja/nee-bevestiging
if (! $this->confirm('Importeren in de productie-DB?')) {
    $this->info('Geannuleerd.');
    return;
}

// Kiezen uit opties
$format = $this->choice('Kies het uitvoerformaat', ['csv', 'json', 'xml'], 0);

Voortgangsbalk

Tijdens het verwerken van grote hoeveelheden data kun je de voortgang overzichtelijk tonen.

use App\Models\Product;

// Geef een collection door en de voortgangsbalk verschijnt automatisch
$this->withProgressBar(Product::cursor(), function (Product $product) {
    $this->processProduct($product);
});

Wil je alles handmatig fijner aansturen, gebruik dan de volgende aanpak.

$total = Product::count();
$bar = $this->output->createProgressBar($total);
$bar->start();

Product::cursor()->each(function (Product $product) use ($bar) {
    $this->processProduct($product);
    $bar->advance();
});

$bar->finish();
$this->newLine();

Praktische use cases

Een data-importcommando

Een praktisch voorbeeld van een commando dat productdata importeert uit een CSV-bestand.

Genereer het commando

php artisan make:command ImportProducts

Implementeer het commando

<?php

namespace App\Console\Commands;

use App\Models\Product;
use Illuminate\Console\Command;

class ImportProducts extends Command
{
    protected $signature = 'import:products
                            {file : Pad naar het CSV-bestand}
                            {--limit= : Maximaal aantal te importeren records}
                            {--dry-run : Alleen controleren (niet opslaan in de DB)}';

    protected $description = 'Importeert productdata uit een CSV-bestand';

    public function handle(): void
    {
        $filePath = $this->argument('file');
        $limit    = $this->option('limit') ? (int) $this->option('limit') : null;
        $dryRun   = $this->option('dry-run');

        if (! file_exists($filePath)) {
            $this->error("Bestand niet gevonden: {$filePath}");
            return;
        }

        // De CSV inlezen met ingebouwde PHP-functies
        $handle = fopen($filePath, 'r');
        $headers = fgetcsv($handle); // De eerste regel als header ophalen
        $rows = [];
        while (($row = fgetcsv($handle)) !== false) {
            $rows[] = array_combine($headers, $row);
            if ($limit !== null && count($rows) >= $limit) {
                break;
            }
        }
        fclose($handle);

        $count = 0;

        $this->withProgressBar($rows, function (array $row) use ($dryRun, &$count) {
            if (! $dryRun) {
                Product::updateOrCreate(
                    ['sku' => $row['sku']],
                    [
                        'name'  => $row['name'],
                        'price' => $row['price'],
                    ]
                );
            }
            $count++;
        });

        $this->newLine();

        if ($dryRun) {
            $this->warn("{$count} records zouden worden verwerkt (dry-run: opslaan overgeslagen)");
        } else {
            $this->info("Import van {$count} records voltooid.");
        }
    }
}

Voer het commando uit

# Normale import
php artisan import:products storage/products.csv

# Het aantal beperken
php artisan import:products storage/products.csv --limit=100

# Controleren met een dry run
php artisan import:products storage/products.csv --dry-run

Een periodiek onderhoudscommando

Een voorbeeld van een onderhoudscommando dat je periodiek uitvoert, zoals het verwijderen van oude data.

<?php

namespace App\Console\Commands;

use App\Models\Order;
use Illuminate\Console\Command;

class PruneOldOrders extends Command
{
    protected $signature = 'orders:prune {--days=90 : Vanaf hoeveel dagen oud data wordt verwijderd}';

    protected $description = 'Verwijdert voltooide bestellingen die ouder zijn dan het opgegeven aantal dagen';

    public function handle(): void
    {
        $days = (int) $this->option('days');

        if (! $this->confirm("Voltooide bestellingen ouder dan {$days} dagen verwijderen?")) {
            $this->info('Geannuleerd.');
            return;
        }

        $deleted = Order::where('status', 'completed')
            ->where('created_at', '<', now()->subDays($days))
            ->delete();

        $this->info("{$deleted} bestellingen verwijderd.");
    }
}

Combineren met geplande uitvoering

Gemaakte commando’s kun je inplannen in routes/console.php. Zie taakplanning voor meer details.

use Illuminate\Support\Facades\Schedule;

// Elke dag om 2:00 uur 's nachts uitvoeren
Schedule::command('orders:prune --days=90')->dailyAt('2:00');

// Elke maandag om 9:00 uur uitvoeren
Schedule::command('import:products storage/weekly.csv')->weeklyOn(1, '9:00');

Commando’s testen

Met de testfunctionaliteit van Laravel kun je de werking van Artisan-commando’s verifiëren.

<?php

namespace Tests\Feature\Commands;

use App\Models\Order;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;

class PruneOldOrdersTest extends TestCase
{
    use RefreshDatabase;

    public function test_it_deletes_old_completed_orders(): void
    {
        // Een afgeronde bestelling van meer dan 90 dagen geleden aanmaken
        Order::factory()->create([
            'status'     => 'completed',
            'created_at' => now()->subDays(100),
        ]);

        // Een recente afgeronde bestelling (zou niet verwijderd mogen worden)
        Order::factory()->create([
            'status'     => 'completed',
            'created_at' => now()->subDays(10),
        ]);

        $this->artisan('orders:prune', ['--days' => 90])
            ->expectsConfirmation('Voltooide bestellingen ouder dan 90 dagen verwijderen?', 'yes')
            ->expectsOutput('1 bestellingen verwijderd.')
            ->assertExitCode(0);

        $this->assertDatabaseCount('orders', 1);
    }

    public function test_it_cancels_when_user_declines(): void
    {
        Order::factory()->create(['status' => 'completed', 'created_at' => now()->subDays(100)]);

        $this->artisan('orders:prune', ['--days' => 90])
            ->expectsConfirmation('Voltooide bestellingen ouder dan 90 dagen verwijderen?', 'no')
            ->expectsOutput('Geannuleerd.')
            ->assertExitCode(0);

        $this->assertDatabaseCount('orders', 1);
    }
}

Voorbeelden van assertion-methoden die je met de artisan()-methode kunt gebruiken:

Methode	Beschrijving
`expectsOutput('...')`	Verifieert dat de opgegeven tekst wordt uitgevoerd
`expectsQuestion('?', 'antwoord')`	Simuleert de invoer van `ask()`
`expectsConfirmation('?', 'yes')`	Simuleert het antwoord van `confirm()`
`expectsChoice('?', 'keuze')`	Simuleert de keuze van `choice()`
`assertExitCode(0)`	Verifieert de exitcode (0 = succes)
`assertFailed()`	Verifieert dat de exitcode niet 0 is

Het `dev`-commando

Het Artisan-commando dev start de verschillende processen die je nodig hebt voor lokale ontwikkeling samen in één terminalvenster. Standaard draaien de PHP-ontwikkelserver, de queue worker, logbewaking via Pail en het compileren van assets met Vite parallel.

php artisan dev

Intern worden de processen beheerd met het npm-pakket @laravel/multiplex. Elk proces krijgt een eigen tab, waarin je de uitvoer kunt doorzoeken en scrollen. Crasht een proces, dan wordt het automatisch herstart, en bij afsluiten wordt de uitvoer teruggeschreven naar de scrollback van de terminal, zodat je geen logs verliest. Het dev-commando vereist Node.js 22.13 of hoger. Op Windows wordt teruggevallen op het npm-pakket concurrently, waardoor de UI met tabs niet beschikbaar is. De processen die standaard worden uitgevoerd zijn:

Naam	Commando
`server`	`php artisan serve --host=localhost`
`queue`	`php artisan queue:listen --tries=1 --timeout=0`
`logs`	`php artisan pail --timeout=0`
`vite`	`npm run dev`

Het vite-proces detecteert automatisch welke Node-pakketmanager je gebruikt (npm, pnpm, Yarn of Bun) en gebruikt het bijbehorende uitvoercommando.

Processen worden maximaal 5 keer herstart. Een proces dat direct na de start (binnen 1 seconde) stopt, wordt niet herstart, omdat dat waarschijnlijk duidt op een fout in het commando of een poortconflict. Om herstarten voor één uitvoering uit te schakelen, geef je --no-restart op.

php artisan dev --no-restart

De `dev`-processen aanpassen

De processen die het dev-commando uitvoert, kun je aanpassen met de klasse DevCommands. Meestal registreer je ze in de boot-methode van de AppServiceProvider van je applicatie. De register-methode ontvangt een commandostring en optioneel een procesnaam.

use Illuminate\Foundation\DevCommands;

/**
 * Bootstrappen van applicatieservices
 */
public function boot(): void
{
    DevCommands::register('some-command --flag', 'my-process');
}

Wil je een Artisan-commando registreren, dan kun je de artisan-methode gebruiken, die automatisch php artisan vooraan zet.

DevCommands::artisan('horizon', 'horizon');

Op dezelfde manier zet de node-methode het runcommando van de gedetecteerde pakketmanager (bijv. npm run) vooraan, en de nodeExec-methode het exec-commando van de pakketmanager (bijv. npx).

DevCommands::node('storybook', 'storybook');

DevCommands::nodeExec('tailwindcss -i resources/css/app.css -o public/css/app.css --watch', 'tailwind');

Registreer je een proces met dezelfde naam als een standaardproces, dan vervangt het dat standaardproces. Zo kun je bijvoorbeeld het serverproces aanpassen om een andere poort te gebruiken.

DevCommands::artisan('serve --host=localhost --port=9000', 'server');

Ook de kleur van het proceslabel in de terminal kun je aanpassen. De beschikbare kleurmethoden zijn blue, purple, pink, orange, green en yellow. Je kunt ook een eigen hexkleur doorgeven aan de color-methode.

DevCommands::register('my-command', 'my-process')->green();

DevCommands::register('my-command', 'my-process')->color('#ff6347');

Wil je de geregistreerde dev-processen bekijken zonder ze daadwerkelijk te starten, gebruik dan het dev:list-commando.

php artisan dev:list

De `dev`-processen filteren

Met de only-methode geef je aan dat bij het uitvoeren van het dev-commando alleen specifieke processen moeten starten. Evenzo kun je met de except-methode specifieke processen uitsluiten.

// Alleen de processen server en vite starten...
DevCommands::only('server', 'vite');

// Alle processen behalve de queue worker starten...
DevCommands::except('queue');

Wil je dev-commando’s uitsluiten die door pakketten zijn geregistreerd, of de standaardcommando’s van Laravel, gebruik dan de methoden withoutVendorCommands en withoutDefaultCommands.

DevCommands::withoutVendorCommands();

DevCommands::withoutDefaultCommands();

Gebruik je bij lokale ontwikkeling ook Horizon of Reverb, registreer ze dan met DevCommands::artisan(). Dan start je alles handig in één keer met php artisan dev.

Overzicht van veelgebruikte commando’s

# Een nieuw commando maken
php artisan make:command CommandName

# Overzicht van beschikbare commando's
php artisan list

# Het gebruik van een commando bekijken
php artisan help command:name

# Tinker starten
php artisan tinker

​Wat is Artisan

​Tinker

​Eigen commando’s maken

​Een commando genereren

​De basisstructuur van een commando

​Argumenten en opties definiëren

​Argumenten en opties ophalen

​input() — getypeerde accessors

​Interactie met de gebruiker

​Berichten uitvoeren

​Vragen stellen aan de gebruiker

​Voortgangsbalk

​Praktische use cases

​Een data-importcommando

​Een periodiek onderhoudscommando

​Combineren met geplande uitvoering

​Commando’s testen

​Het dev-commando

​De dev-processen aanpassen

​De dev-processen filteren

​Overzicht van veelgebruikte commando’s

Wat is Artisan

Tinker

Eigen commando’s maken

Een commando genereren

De basisstructuur van een commando

Argumenten en opties definiëren

Argumenten en opties ophalen

`input()` — getypeerde accessors

Interactie met de gebruiker

Berichten uitvoeren

Vragen stellen aan de gebruiker

Voortgangsbalk

Praktische use cases

Een data-importcommando

Een periodiek onderhoudscommando

Combineren met geplande uitvoering

Commando’s testen

Het `dev`-commando

De `dev`-processen aanpassen

De `dev`-processen filteren

Overzicht van veelgebruikte commando’s