Symfony Knowledge Base

Quick reference for Symfony framework patterns, DDD integration, and PHP implementation guidelines for auditing and generating Symfony-based applications.

Core Principles

• Bundle System — Symfony's plugin mechanism. Third-party code is installed as bundles; application code lives outside bundles in

  src/

  .
• Symfony Flex — Automates bundle installation via recipes. Standard dirs:

  config/

  ,

  src/

  ,

  public/

  ,

  var/

  ,

  migrations/

  ,

  tests/

  ,

  templates/

  .
• Kernel — Entry point that boots the container, registers bundles, loads configuration. Must remain thin — no business logic.

Quick Checklists

DDD-Compatible Symfony Project

• Domain layer has zero Symfony imports
• Doctrine mapping uses XML or PHP config (not entity attributes)
• Controllers are invokable (single action per class)
• Messenger handles commands and queries via separate buses
• Value Objects use custom Doctrine types
• Repository interfaces in Domain, implementations in Infrastructure

• services.yaml

  binds interfaces to implementations
• Domain events are dispatched, not Doctrine lifecycle events
• Authorization uses Voters delegating to domain Specifications
• Workflow guards delegate to domain Specifications (no inline business logic)
• Domain defines its own

  EventDispatcherInterface

  (not Symfony's)
• Infrastructure components (Cache, HTTP Client) accessed via domain ports

Clean Architecture in Symfony

• No

  use Symfony\

  in Domain or Application layers
• No

  use Doctrine\

  in Domain layer
• Use Cases accept Command/Query DTOs, not Request objects
• Controllers only map HTTP to Use Case calls
• EventSubscribers do not contain business logic
• Compiler passes do not encode domain rules

Common Violations Quick Reference

Domain/**/*.php

#[ORM\

Application/**/*.php

if

switch

$container->get()

EventListener

$container->get('service.id')

Domain/**/*.php

implements UserInterface

messenger.yaml

retry_strategy

Domain/**/*.php

use Symfony\Contracts\EventDispatcher

Application/**/*.php

CacheInterface

LockFactory

PHP 8.4 Symfony Patterns

Invokable Controller (Single Action)

<?php
declare(strict_types=1);
namespace App\Order\Presentation\Api;

use App\Order\Application\Command\CreateOrderCommand;
use App\Order\Application\UseCase\CreateOrderUseCase;
use Symfony\Component\HttpFoundation\{JsonResponse, Request, Response};
use Symfony\Component\Routing\Attribute\Route;

#[Route('/api/orders', methods: ['POST'])]
final readonly class CreateOrderAction
{
    public function __construct(private CreateOrderUseCase $createOrder) {}

    public function __invoke(Request $request): JsonResponse
    {
        $data = $request->toArray();
        $orderId = $this->createOrder->execute(new CreateOrderCommand(
            customerId: $data['customer_id'],
            items: $data['items'],
        ));

        return new JsonResponse(['id' => $orderId->value], Response::HTTP_CREATED);
    }
}

Use Case (Application Service)

<?php
declare(strict_types=1);
namespace App\Order\Application\UseCase;

use App\Order\Domain\Entity\Order;
use App\Order\Domain\Repository\OrderRepositoryInterface;
use App\Shared\Domain\EventDispatcherInterface;

final readonly class CreateOrderUseCase
{
    public function __construct(
        private OrderRepositoryInterface $orders,
        private EventDispatcherInterface $events,
    ) {}

    public function execute(CreateOrderCommand $command): OrderId
    {
        $order = Order::create($command->customerId, $command->items);
        $this->orders->save($order);

        foreach ($order->releaseEvents() as $event) {
            $this->events->dispatch($event);
        }

        return $order->id();
    }
}

Messenger Command Handler

<?php
declare(strict_types=1);
namespace App\Order\Application\Handler;

use App\Order\Application\Command\ConfirmOrderCommand;
use App\Order\Domain\Repository\OrderRepositoryInterface;
use Symfony\Component\Messenger\Attribute\AsMessageHandler;

#[AsMessageHandler(bus: 'command.bus')]
final readonly class ConfirmOrderHandler
{
    public function __construct(private OrderRepositoryInterface $orders) {}

    public function __invoke(ConfirmOrderCommand $command): void
    {
        $order = $this->orders->findById($command->orderId);
        $order->confirm();
        $this->orders->save($order);
    }
}

References

For detailed information, load these reference files:

• references/architecture.md

  — Bundle system, Flex recipes, standard vs DDD-aligned directory layout

• references/ddd-integration.md

  — Domain purity, Messenger CQRS, Domain Events, Value Objects with Doctrine

• references/routing-http.md

  — Invokable controllers, EventSubscribers, attribute routing, validation

• references/persistence.md

  — Doctrine ORM mapping, repositories, migrations, keeping Doctrine out of Domain

• references/dependency-injection.md

  — services.yaml, auto-wiring, tagged services, compiler passes, interface binding

• references/testing.md

  — WebTestCase, KernelTestCase, functional tests, fixtures, Messenger handler testing

• references/security.md

  — UserInterface adapter, Voters with Specifications, firewalls, password hashing, auth events

• references/messenger-advanced.md

  — Multiple buses, transports, retry strategy, DLQ, middleware, workers, serialization

• references/workflow.md

  — StateMachine for aggregates, enum places, guards with Specifications, audit trail

• references/event-system.md

  — EventDispatcher patterns, kernel events, domain event dispatching, PSR-14

• references/infrastructure-components.md

  — Cache, Lock, RateLimiter, HTTP Client, Serializer, Scheduler with DDD ports

• references/antipatterns.md

  — Fat controllers, entity as DTO, Doctrine in Domain, Service Locator, detection patterns