Ce partage explique comment utiliser Symfony 7 et Mercure pour créer une session live réactive sans WebSocket. L'auteur, Jean-Sébastien Christophe, explore l'intégration de Mercure, un protocole de Server-Sent Events (SSE), pour gérer des états de session en temps réel, comme la présence des utilisateurs, sans nécessiter de requêtes répétées ou de boucles côté client. Il détaille la stack technique utilisée (Symfony 7.3, PHP 8.4, Docker, PostgreSQL, MailCatcher) et les avantages de Mercure pour des applications temps réel, tout en prévoyant une future intégration avec FrankenPHP pour optimiser les performances et la sécurité.

Un bundle Symfony pour utiliser les Google Fonts sans enfreindre le RGPD

Cet article explique comment Symfony utilise la classe ReflectionClass de PHP pour offrir sa flexibilité et son automatisation. Voici les points clés :

• Injection de dépendances : Symfony inspecte les constructeurs des classes via ReflectionClass pour identifier et injecter automatiquement les dépendances typées, sans configuration manuelle.
• Routing et contrôleurs : Grâce à la réflexion, Symfony lit les attributs de route (comme #[Route]) et injecte dynamiquement les arguments des méthodes de contrôleur (ex. : récupération d’une entité depuis la base via le ParamConverter).
• Sérialisation : Le composant Serializer utilise la réflexion pour découvrir les propriétés et leurs types, permettant une conversion automatique entre objets et formats comme JSON/XML.

En résumé, la Reflection API est au cœur de la magie de Symfony, rendant possible l’injection de dépendances, le routage intelligent et la manipulation des données sans configuration statique.

Cet article présente une approche pragmatique pour construire une application SaaS multi-tenant avec Symfony, en utilisant une base de données partagée et une seule codebase pour plusieurs clients (tenants). L’article s’appuie sur l’expérience de l’auteur, qui a développé une plateforme pour des marques de retail, chacune ayant ses propres magasins, utilisateurs et règles d’accès.

Points clés :

• Résolution du tenant : Identification du client actif via la session (back-office) ou le sous-domaine (front-office), stockée dans un service TenantContext accessible partout dans l’application.
• Isolation des données : Toutes les entités liées à un client incluent un brand_id, et les requêtes sont automatiquement filtrées par ce contexte.
• Contrôle d’accès (ACL) : Gestion des fonctionnalités et permissions par client via des listes de contrôle d’accès (ACL) et des voters Symfony, permettant d’activer/désactiver des fonctionnalités par marque.
• Architecture unifiée : Le même TenantContext est utilisé pour le back-office (session) et le front-office (domaine), garantissant une cohérence et une sécurité optimale.

L’article insiste sur la simplicité, la maintenabilité et l’évolutivité de cette solution, idéale pour les SaaS nécessitant une isolation des données sans complexité infrastructurelle.

Cet article explique comment construire un serveur Model Context Protocol (MCP) pour une application Symfony, permettant à des assistants IA comme Claude d’interagir directement avec vos données et fonctionnalités via des requêtes en langage naturel.

Le tutoriel propose un exemple concret : une application de gestion de clients avec Symfony, où l’on ajoute un serveur MCP pour permettre à l’IA de rechercher des clients, consulter leurs commandes, analyser des statistiques, etc. Il détaille les étapes clés : installation du SDK MCP, création de "tools" (outils) en PHP avec des attributs, configuration d’un serveur MCP, et intégration avec Claude Desktop. Le projet utilise une base SQLite avec des entités Customer, Order, OrderItem et Product, et fournit des exemples de requêtes possibles (recherche par nom, ville, top dépensiers, etc.).

Le code source est disponible sur GitHub, et le tutoriel inclut des captures d’écran de l’interface. Une bonne ressource pour les développeurs PHP/Symfony souhaitant connecter leurs applications à des assistants IA via MCP.

Symfony propose AssetMapper, une solution radicalement simple pour gérer les assets (JS, CSS, images) sans recourir à Node.js ou à des outils de build complexes comme Webpack. Basé sur la technologie native des navigateurs importmap, AssetMapper permet d’utiliser directement les imports ES6 dans le navigateur, sans étape de compilation. Il génère automatiquement une balise <script type="importmap"> qui mappe vos dépendances et vos fichiers locaux, et gère le versionnage des assets pour un cache busting efficace. L’installation se fait via Composer, et une simple commande (bin/console importmap:require) suffit pour ajouter une bibliothèque JS, qui est ensuite téléchargée depuis un CDN et stockée localement. En production, une commande (asset-map:compile) copie et versionne les fichiers dans public/assets/, avec option de pré-compression Gzip. Pour la minification, le bundle sensiolabs/minify-bundle s’intègre parfaitement. Résultat : zéro build, zéro npm, et une gestion des assets simplifiée et performante, idéale pour les applications Symfony classiques ou utilisant Hotwire/Stimulus. Une approche minimaliste et efficace pour ceux qui veulent éviter la complexité du frontend moderne.

L’article met en lumière l’impact des attributs PHP 8 sur l’écosystème Symfony, remplaçant progressivement les annotations et le YAML pour une configuration plus moderne et unifiée (routes, sécurité, Doctrine, DTOs). Il souligne aussi des innovations comme les Property Hooks de PHP 8.4 avec Doctrine 3.4, qui simplifient la gestion des getters/setters, ainsi que l’introduction des Live Components et Twig Components, permettant une approche plus réactive et typée du front-end, sans JavaScript. Une évolution majeure pour les développeurs Symfony, vers plus de simplicité et de puissance.

Cet article explique comment résoudre les erreurs CORS liées aux requêtes OPTIONS dans Symfony 7, un problème fréquent lors du développement d'applications modernes avec des architectures microservices ou SPA. L'erreur survient lorsque le navigateur envoie une requête OPTIONS (preflight) pour vérifier si une requête cross-origin est autorisée, mais Symfony ne la gère pas correctement, provoquant une erreur "Access-Control-Allow-Origin".

La solution proposée consiste à créer un Event Subscriber (CorsSubscriber) qui intercepte les requêtes OPTIONS avant qu'elles n'atteignent le routeur. Ce subscriber renvoie une réponse HTTP 200 avec les en-têtes CORS nécessaires (Access-Control-Allow-Origin, Access-Control-Allow-Methods, etc.), empêchant ainsi Symfony de chercher une route inexistante ou de générer une erreur. L'article détaille le code à implémenter, l'importance de la priorité élevée (9999) pour bloquer l'exécution du routeur, et souligne l'utilité de cette approche pour garantir la compatibilité des APIs Symfony avec les applications frontend modernes. Une solution propre, performante et indépendante des routes spécifiques.

L’article de Bohdan Pastukh critique l’approche souvent enseignée par la documentation Symfony, qui pousse vers un Anemic Domain Model : les entités (comme User) se réduisent à des conteneurs de données avec des getters/setters, tandis que la logique métier est déplacée vers des services externes (ex : ContactDataService). L’auteur souligne que cette pratique, bien que courante dans les tutoriels, conduit à un code moins cohésif et moins orienté objet. Il encourage à privilégier les Rich Models, où la logique métier est encapsulée directement dans les entités, pour un design plus robuste et maintenable.

Exemple critiqué :

class User {
    private string $contactType;
    private string $contact;
    public function setContactType(string $contactType): void { ... }
    public function setContact(string $contact): void { ... }
}
class ContactDataService {
    public function changeContactData(string $contactType, string $contact): void { ... }
}

Alternative suggérée : Intégrer la validation et la logique dans l’entité User elle-même.

L’article explique comment automatiser la découverte et l’enregistrement des commandes console dans une application PHP utilisant le framework Power Modules et Symfony Console. L’auteur part du constat que la registration manuelle des commandes (via une boucle sur les modules et leurs composants exportés) est répétitive et peu élégante. Il propose une solution basée sur un PowerModuleSetup dédié, qui s’intègre au cycle de vie des modules pour collecter et enregistrer automatiquement les commandes, en s’appuyant sur le conteneur de dépendances de Symfony. La solution évolue vers une approche optimisée avec un ContainerCommandLoader, permettant un chargement paresseux des commandes. Le résultat est un code plus modulaire, réutilisable et sans duplication, idéal pour les architectures basées sur Power Modules. Le package est disponible via Composer : power-modules/console.

Ce billet explique comment tirer pleinement parti du composant symfony/object-mapper, bien au-delà d'une simple hydratation d'objets à partir de tableaux. L'auteur montre que cet outil, basé sur le puissant Serializer de Symfony, permet de gérer des cas avancés comme la création de DTO immutables (avec promotion de propriétés dans le constructeur), la gestion de structures imbriquées et de collections, l'application de logiques personnalisées (ex : conversion de chaînes en DateTimeImmutable), et l'adaptation entre différentes conventions de nommage (snake_case ↔ camelCase). Grâce à des exemples concrets en Symfony 7.3, il démontre comment configurer et utiliser l'ObjectMapper pour des transformations de données élégantes et maintenables, tout en intégrant la validation et la gestion des erreurs. Un guide pratique pour optimiser la manipulation de données dans des applications PHP modernes.

L’article explique comment améliorer l’UX d’un site en affichant automatiquement les favicons devant les liens externes, sans JavaScript ni surcharge inutile. L’auteur utilise une approche côté serveur (via un MarkdownProcessor en PHP) pour détecter les liens externes, ajouter dynamiquement leur favicon via l’API publique de DuckDuckGo, et appliquer des attributs de sécurité (target="_blank", rel="noreferrer nofollow"). Le CSS assure un alignement parfait et un soulignement du texte seulement. Résultat : une navigation plus intuitive et visuellement claire, avec un impact minimal sur les performances grâce au lazy loading et au cache HTTP. Une astuce simple mais efficace pour soigner les détails et renforcer la confiance des utilisateurs.

Les Live Components de Symfony permettent de créer des interfaces réactives en PHP/Twig, sans JavaScript : une classe PHP gère la logique et l’état (avec #[LiveProp] et #[LiveAction]), tandis que le template Twig affiche et déclenche les actions via data-action="live#action" et data-model. Exemple : un menu dynamique, une recherche en temps réel (avec debounce intégré), ou des mises à jour partielles du DOM — le tout avec typage strict, validation, et optimisations (cache, requêtes limitées). Réactivité côté serveur, simplicité côté dev.

Les Twig Components permettent de créer des composants réutilisables et typés en PHP/Twig, inspirés de React/Vue, mais sans JavaScript.

Points clés :

• #[AsTwigComponent] : Déclare un composant (ex: Hero) avec son template Twig.
• #[ExposeInTemplate] : Expose des méthodes/propriétés dans le template (ex: {{ punchline }}).
• Architecture claire : Séparation logique (classe PHP) et affichage (template), avec typage strict.
• Avantages : Réutilisabilité, encapsulation, cache intégré, et fin du mélange logique/affichage.

Exemple :

#[AsTwigComponent(name: 'Hero', template: 'components/Layout/Hero.html.twig')]
class Hero {
    #[ExposeInTemplate('punchline')]
    public function getPunchline(): ?PunchlineEntity { ... }
}

→ Des composants modernes, mais 100% Symfony.

Les-Tilleuls.coop a conçu un site immersif pour célébrer les 20 ans de Symfony, basé sur une timeline interactive pilotée par le scroll, avec un design inspiré du logo anniversaire. Chaque section représente une année clé, avec des animations fluides pour plonger l’utilisateur dans l’histoire du framework. Les défis techniques incluaient l’optimisation des performances (chargement progressif des animations) et la gestion des décalages de scroll sous Firefox (corrigés via un ajustement manuel du positionnement). Un projet alliant narratif visuel et expertise UX/UI, pour rendre hommage à un outil central dans leur quotidien depuis 15 ans.

Le ForumPHP 2025 marque un tournant discret mais puissant pour l’écosystème PHP : loin d’une simple commémoration des 30 ans du langage, la conférence a mis en lumière une communauté en pleine mutation, entre innovations techniques (FrankenPHP, IA, performance, packaging binaire) et une gouvernance renforcée via la PHP Foundation. Elle souligne la maturité du langage tout en prouvant qu’il continue de repousser ses limites, porté par une dynamique collective tournée vers l’avenir.

Ce guide pratique explique comment maîtriser les migrations de base de données avec Symfony 7 et Doctrine. Il couvre l'installation d'un projet Symfony, la création d'entités, la génération et l'application des migrations, ainsi que leur réversion. L'article détaille aussi la personnalisation des migrations (méthodes preUp, postUp, preDown, postDown, gestion des transactions, etc.), l'évolution des propriétés d'entités, et propose une solution pour éviter l'erreur récurrente de création du schéma public avec PostgreSQL. Un template personnalisé pour les migrations et un listener Doctrine sont présentés pour optimiser le workflow. Enfin, une cheatsheet récapitule les commandes utiles pour gérer les migrations efficacement. Idéal pour les développeurs souhaitant approfondir la gestion des schémas de base de données dans Symfony.

Le Command Logger Bundle pour Symfony est un outil conçu pour suivre l'exécution des commandes console directement dans une base de données, idéal lorsque l'accès aux fichiers de log est impossible. Il enregistre pour chaque commande : son nom, ses arguments, les horaires de début et de fin, le code de sortie, les messages d'erreur et un identifiant unique. Simple à installer via Composer, il permet de configurer les commandes à logger (via attributs ou fichier YAML) et offre des commandes CLI pour consulter, filtrer ou purger les logs. Son objectif principal est de répondre rapidement à des questions clés : la commande a-t-elle été exécutée ? Quand ? Avec quel résultat ? Il ne capture pas la sortie console, mais fournit une traçabilité essentielle pour le débogage et l'audit.

Ce tutoriel explique comment implémenter le Design Pattern Strategy dans Symfony, en partant d’une approche naïve avec des if/else pour aboutir à une solution professionnelle et maintenable. L’objectif est de créer un système d’analyse de céréales (blé, orge, tournesol, etc.) qui puisse s’étendre facilement sans modifier le code existant.

L’auteur détaille trois étapes :

1. Approche naïve avec des if/else ou match (PHP 8+), simple mais peu extensible et difficile à maintenir.
2. Solution optimale avec le Strategy Pattern : chaque type de céréale est géré par une classe indépendante (stratégie) implémentant une interface commune. Symfony utilise des attributs comme #[AutoconfigureTag] et #[AutowireIterator] pour injecter automatiquement les stratégies dans un manager, qui délègue l’analyse à la stratégie adaptée.
3. Avantages : respect du principe ouvert/fermé, testabilité, et extensibilité (ajouter une céréale = ajouter une classe).

Le tutoriel inclut des exemples concrets, des comparatifs, et un projet GitHub pour illustrer la mise en œuvre. Une ressource idéale pour comprendre comment structurer du code Symfony flexible et évolutif.

L’API Platform Conference 2025 célèbre les 10 ans du framework avec des annonces fortes et un double focus : performance extrême et expérience développeur (DX). Côté performance, l’intégration d’extensions PHP écrites en Go (via FrankenPHP) et le support natif de gRPC pour PHP ont volé la vedette, permettant des gains inédits en rapidité et stabilité, comme en témoigne l’adoption par Laravel Cloud. API Platform 4.2 a aussi été dévoilé, avec des outils comme l’ObjectMapper de Symfony pour simplifier la transformation d’objets et des gains de performance multipliés par 2 ou 3.

La deuxième journée a mis l’accent sur la DX : schémas JSON pour la configuration YAML dans Symfony, l’arrivée de PIE (remplaçant moderne de PECL), et des réflexions sur l’Agent Experience (AX) pour mieux collaborer avec les IA. Fabien Potencier a notamment proposé d’ajouter un fichier llms.txt pour faciliter l’intégration des LLM. Enfin, des conférences sur les feature flags, la contribution au cœur de PHP, et l’histoire des femmes dans la tech ont rappelé l’importance de l’humain et de l’outillage moderne. En résumé, PHP se réinvente comme un écosystème hybride, performant et centré sur les développeurs, invitant à tester FrankenPHP, adopter les nouvelles pratiques DevOps et repenser l’architecture des projets. Une édition résolument tournée vers l’avenir ! 🚀