Supercharge Your Symfony Console Commands with Invokable Controllers in 7.3

Symfony 7.3 is bringing a streamlined approach to console commands: invokable commands. This feature simplifies your code, making it cleaner and easier to understand. Learn how invokable commands can help you write better Symfony applications.

What are Symfony Invokable Commands?

Invokable commands let you define a class with a single, publicly accessible __invoke method. This method acts as the entry point for your command, reducing boilerplate and improving code clarity. If your class has one main job, turn it into an invokable class.

Benefits of Using Invokable Commands in Symfony

• Reduced Boilerplate: Say goodbye to execute or handle methods and complicated configuration setups.

• Enhanced Readability: It is immediately obvious which method will be executed.

• Automatic Argument Handling: Automatically inject command-line arguments and options as method parameters. No more $input->getArgument('name')!

Code Comparison: Old vs. New Symfony Command Style

See the difference firsthand:

Before (Traditional Symfony Command):

class CreateUserCommand extends Command 
{
    protected function configure(): void
    {
        $this->addArgument('name', InputArgument::REQUIRED);
        $this->addOption('activate', null, InputOption::VALUE_NONE);
    }
}

After (Symfony Invokable Command):

class CreateUserCommand
{
    public function __invoke(
        SymfonyStyle $io,
        #[Argument] string $name,
        #[Option] bool $activate = false,
    ): int {
        // Code here
    }
}

Invokable commands eliminate the need for the configure method and manual retrieval of arguments. Using Symfony's attributes simplify the handling of arguments and options.

Streamlining Command Arguments and Options

In the past, you'd need to define arguments and options within the configure() method and then retrieve them individually. Symfony 7.3 introduces a cleaner way:

• Type Hinting: Define your arguments and options directly as parameters in the __invoke method.
• Attributes: Using attributes (#[Argument], #[Option]) automatically map command-line inputs to your method parameters.

This eliminates the need for manual parsing and reduces the amount of code you need to write.

Why This Matters: Single Responsibility Principle

The traditional approach of using a text signature that gets parsed to generate content violates the single responsibility principle. Invokable commands promote cleaner code that is focused on the core functionality.

The Future of Laravel Commands

While this article focuses on Symfony, the author also touches on Laravel. Since Laravel commands extend from Symfony, the author expects that it is only a matter of time before Laravel adopts invokable controllers as they are too big of a code reduction to ignore.