Getting Started

Minimal Steps

Installation
```
composer require symfony/maker-bundle --dev
```
Register the bundle in config/bundles.php (auto-discovered in Symfony 4.3+).
First Command Generate a basic controller:
```
php bin/console make:controller
```
Follow prompts (e.g., Blog/PostController, --format=annotation).
Key Files to Review
- config/packages/maker.yaml (customization options).
- src/Maker/ (default maker classes, e.g., ControllerMaker.php).

First Use Case: Scaffold a CRUD Entity

php bin/console make:crud Post blog/post

Generates:
- Entity (Post with timestamps, slug, etc.).
- Controller (with index, show, new, edit, update, delete).
- Form type (PostType).
- Twig templates (index.html.twig, edit.html.twig, etc.).
- Repository interface (PostRepository).
Pro Tip: Use --no-src to skip source files (e.g., for API-only projects).

Implementation Patterns

Core Workflows

Entity Generation with Relationships
```
php bin/console make:entity Post
```
- Add fields interactively (e.g., title:string, content:text).
- Define relationships (e.g., ManyToOne:User).
- Output: Migrations, entity class, and repository.

Customizing Makers Extend Maker\Maker to create reusable templates:

// src/Maker/CustomControllerMaker.php
namespace App\Maker;

use Symfony\Bundle\MakerBundle\Maker\Generator;
use Symfony\Bundle\MakerBundle\Maker\MakerInterface;
use Symfony\Bundle\MakerBundle\InputConfiguration;
use Symfony\Bundle\MakerBundle\Str;

class CustomControllerMaker implements MakerInterface
{
    public function configureInput(InputConfiguration $input): void
    {
        $input->setOption('format', 'annotation');
    }

    public function generate(InputConfiguration $input, Generator $generator): void
    {
        $name = Str::asClassName($input->getArgument('name'));
        $generator->generateClass(...);
    }
}

makers:
    custom_controller:
        command: make:custom-controller
        class: App\Maker\CustomControllerMaker

CRUD with API Support Use --api flag for API-specific CRUD:
```
php bin/console make:crud Post blog/post --api
```
- Generates:
  - Serializer groups (@Groups({"post:read", "post:write"})).
  - API platform resources (if installed).
  - JSON responses.
Form Types Generate a form for an existing entity:
```
php bin/console make:form PostType Post
```
- Customize fields with --fields (e.g., --fields="title:text(255)").
Event Listeners/Subscribers
```
php bin/console make:event-listener
```
- Choose event (e.g., Kernel::TERMINATE).
- Define logic in the generated class.

Integration Tips

Doctrine Fixtures: Combine with doctrine/doctrine-fixtures-bundle to auto-generate fixtures for new entities:
```
php bin/console make:fixtures
```
API Platform: Use --api with api-platform/core for instant API endpoints.
Symfony UX: Pair with symfony/ux for Turbo/Stimulus-ready templates:
```
php bin/console make:crud Post blog/post --format=turbo
```
Testing: Generate test classes alongside entities/controllers:
```
php bin/console make:test
```

Gotchas and Tips

Pitfalls

Namespace Conflicts
- If your bundle/class names conflict with Symfony’s, override the getTemplate() method in custom makers to point to your own templates (e.g., templates/custom/controller.twig).
Overwriting Existing Files
- Makers default to --force (overwrite). Use --dry-run to preview changes:
```
php bin/console make:crud Post blog/post --dry-run
```
- To skip existing files, use --no-backup (but back up manually first).
Doctrine Migrations
- Entity makers generate migrations, but they may conflict with existing ones. Run:
```
php bin/console make:migration
```
  after generation to update the migration table.
Twig Template Paths
- Custom templates must be placed in templates/maker/ (relative to your bundle) or configured in maker.yaml:
```
templates:
    maker: '%kernel.project_dir%/custom_templates'
```
PHP 8+ Attributes
- If using PHP 8+, ensure your composer.json has "platform": { "php": "8.1" } to avoid attribute parsing issues.

Debugging

Dry Runs Always use --dry-run to inspect generated code before applying:
```
php bin/console make:controller --dry-run
```
Log Output Enable debug mode to see maker execution details:
```
php bin/console debug:maker
```

Custom Maker Debugging Add dump() calls in your custom maker’s generate() method to inspect variables:

public function generate(InputConfiguration $input, Generator $generator): void
{
    dump($input->getArgument('name')); // Debug input
    $generator->generateClass(...);
}

Tips

Aliases for Speed Create shell aliases in ~/.bashrc or ~/.zshrc:

alias makec="php bin/console make:crud"
alias makee="php bin/console make:entity"

Template Customization Override default Twig templates (e.g., controller.twig) in templates/maker/ to modify generated code globally.
Environment-Specific Generation Use --env=test to generate test-specific files (e.g., controllers with @IsGranted("ROLE_TEST")).
IDE Integration
- PHPStorm: Mark src/Maker/ as a "Generated Source Root" to avoid IDE warnings.
- VSCode: Add to settings.json:
```
"files.exclude": {
    "**/src/Maker/**": false
}
```

Post-Generation Hooks Use Symfony’s kernel.terminate event to run scripts after generation (e.g., auto-commit changes):

// config/services.yaml
App\EventListener\PostMakeListener:
    tags:
        - { name: kernel.event_listener, event: kernel.terminate, method: onTerminate }

Performance
- Cache generated files in var/cache/dev/maker (cleared on cache:clear).
- For large projects, regenerate makers occasionally to avoid template drift.
Team Consistency
- Commit maker-generated files to version control (e.g., .gitignore exceptions for src/Entity/, src/Controller/).
- Document custom makers in CONTRIBUTING.md for onboarding.
Legacy Code
- Use --with-doctrine-orm=false for non-Doctrine projects (e.g., Eloquent).
- For Symfony 3.x, pin to ^1.0 in composer.json (Symfony Maker Bundle requires Symfony 4.3+).

Maker Bundle Laravel Package