Symfony 8 — aide-mémoire et correspondances

use Symfony\Component\Routing\Attribute\Route;
use Symfony\Component\Routing\Requirement\Requirement;

#[Route('/articles', name: 'app_article_')]
class ArticleController extends AbstractController
{
    #[Route('', name: 'index', methods: ['GET'])]
    public function index(
        #[MapQueryParameter] int $page = 1,
    ): Response { … }

    #[Route('/{slug}', name: 'show', methods: ['GET'])]
    public function show(
        #[MapEntity(mapping: ['slug' => 'slug'])] Article $article,
    ): Response { … }

    #[Route('/{id}', requirements: ['id' => Requirement::DIGITS])]
    public function byId(int $id): Response { … }

    #[Route('/api', methods: ['POST'])]
    public function create(
        #[MapRequestPayload] CreateArticleDto $dto,
    ): JsonResponse { … }
}

$this->render('x.html.twig', []);
$this->json($data, 200, [], ['groups' => ['article:read']]);
$this->redirectToRoute('app_article_index');
$this->addFlash('success', 'Enregistré.');
$this->getUser();
$this->denyAccessUnlessGranted('EDIT', $article);
throw $this->createNotFoundException();
$this->generateUrl('app_article_show', ['id' => $id]);

#[ORM\Entity(repositoryClass: ArticleRepository::class)]
#[ORM\Index(columns: ['status', 'published_at'])]
class Article
{
    #[ORM\Id, ORM\GeneratedValue, ORM\Column]
    private ?int $id = null;

    #[ORM\Column(length: 255)]
    #[Assert\NotBlank]
    private string $title;

    #[ORM\Column(enumType: ArticleStatus::class)]
    private ArticleStatus $status = ArticleStatus::Draft;

    #[ORM\ManyToOne(inversedBy: 'articles')]
    #[ORM\JoinColumn(nullable: false, onDelete: 'CASCADE')]
    private User $author;

    #[ORM\OneToMany(mappedBy: 'article', targetEntity: Comment::class,
                    orphanRemoval: true, cascade: ['persist'])]
    private Collection $comments;
}

public function findPublishedWithAuthors(int $limit = 10): array
{
    return $this->createQueryBuilder('a')
        ->addSelect('u')                       // évite le N+1
        ->join('a.author', 'u')
        ->andWhere('a.publishedAt IS NOT NULL')
        ->andWhere('a.status = :status')
        ->setParameter('status', ArticleStatus::Published)
        ->orderBy('a.publishedAt', 'DESC')
        ->setMaxResults($limit)
        ->getQuery()
        ->getResult();
}

$form = $this->createForm(ArticleType::class, $article);
$form->handleRequest($request);

if ($form->isSubmitted() && $form->isValid()) {
    $this->em->persist($article);
    $this->em->flush();

    $this->addFlash('success', 'Article enregistré.');

    return $this->redirectToRoute('app_article_index');
}

return $this->render('article/new.html.twig', ['form' => $form]);

#[Assert\NotBlank(message: 'Le titre est obligatoire.')]
#[Assert\Length(min: 3, max: 255)]
private string $title;

#[Assert\Email(mode: 'strict')]
private string $email;

#[Assert\Choice(choices: ['draft', 'published'])]
private string $status;

#[Assert\GreaterThan('today')]
private \DateTimeImmutable $eventDate;

#[Assert\Valid]
private Address $address;

#[Assert\File(maxSize: '2M', mimeTypes: ['image/jpeg', 'image/png'])]
private ?UploadedFile $cover = null;

// Sur la classe
#[UniqueEntity(fields: ['slug'], message: 'Ce slug existe déjà.')]

security:
    password_hashers:
        Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface: 'auto'

    providers:
        app_user_provider:
            entity: { class: App\Entity\User, property: email }

    firewalls:
        dev:
            pattern: ^/(_(profiler|wdt)|css|images|js)/
            security: false
        main:
            lazy: true
            provider: app_user_provider
            form_login:
                login_path: app_login
                check_path: app_login
                enable_csrf: true
            logout:
                path: app_logout

    access_control:
        - { path: ^/admin, roles: ROLE_ADMIN }
        - { path: ^/profil, roles: IS_AUTHENTICATED_FULLY }

class ArticleVoter extends Voter
{
    protected function supports(string $attribute, mixed $subject): bool
    {
        return in_array($attribute, ['EDIT', 'DELETE'])
            && $subject instanceof Article;
    }

    protected function voteOnAttribute($attribute, $subject, TokenInterface $token): bool
    {
        $user = $token->getUser();

        return $user instanceof User && $subject->getAuthor() === $user;
    }
}

#[IsGranted('EDIT', subject: 'article')]
public function edit(Article $article): Response { … }

$this->denyAccessUnlessGranted('EDIT', $article);
public function profile(#[CurrentUser] User $user): Response { … }

class InvoiceGenerator
{
    public function __construct(
        private readonly EntityManagerInterface $em,
        #[Autowire('%app.upload_dir%')] private readonly string $uploadDir,
        #[Autowire(env: 'STRIPE_KEY')] private readonly string $stripeKey,
        #[Autowire(service: 'monolog.logger.billing')] private readonly LoggerInterface $log,
    ) {}
}

#[AutoconfigureTag('app.exporter')]
interface ExporterInterface { … }

class ExportManager
{
    public function __construct(
        #[AutowireIterator('app.exporter')] private iterable $exporters,
    ) {}
}

#[AsDecorator(decorates: MailerInterface::class)]
class LoggingMailer implements MailerInterface { … }

#[When(env: 'dev')]
class FakePaymentGateway implements PaymentGatewayInterface { … }

final readonly class SendInvoiceEmail
{
    public function __construct(public int $invoiceId) {}
}

#[AsMessageHandler]
final class SendInvoiceEmailHandler
{
    public function __invoke(SendInvoiceEmail $message): void { … }
}

$bus->dispatch(new SendInvoiceEmail($id));
$bus->dispatch(new SendInvoiceEmail($id), [new DelayStamp(60000)]);

class ArticleControllerTest extends WebTestCase
{
    public function testIndexAfficheLesArticles(): void
    {
        $client = static::createClient();
        $crawler = $client->request('GET', '/articles');

        $this->assertResponseIsSuccessful();
        $this->assertSelectorTextContains('h1', 'Articles');
        $this->assertCount(10, $crawler->filter('article.card'));
    }

    public function testSoumissionFormulaire(): void
    {
        $client = static::createClient();
        $client->loginUser($this->getUser());
        $client->submitForm('Enregistrer', ['article[title]' => 'Bonjour']);

        $this->assertResponseRedirects();
    }
}

git pull origin main
composer install --no-dev --optimize-autoloader --classmap-authoritative

composer dump-env prod

APP_ENV=prod php bin/console cache:clear
APP_ENV=prod php bin/console cache:warmup
APP_ENV=prod php bin/console doctrine:migrations:migrate -n
APP_ENV=prod php bin/console asset-map:compile
APP_ENV=prod php bin/console messenger:stop-workers