Feat: New codelabs about composition & generics (PHP Symfo)

_tutorials/fr/2023-11-22-composition-over-inheritance-et-typage-generique-avec-symfony-et-doctrine/index.md

@@ -0,0 +1,24 @@
+---
+contentType: tutorial
+lang: fr
+date: '2023-11-22'
+slug: composition-over-inheritance-et-typage-generique-avec-symfony-et-doctrine
+title: Composition over inheritance et typage générique avec Symfony et Doctrine
+excerpt: >-
+  Abordons ensemble une solution pour utiliser l'injection de dépendance plutôt que l'héritage pour créer nos Repository Doctrine, tout en tirant parti du typage générique grâce à PHPStan.
+categories:
+  - php
+authors:
+  - ajacquemin
+keywords:
+  - symfony
+  - composition
+  - inheritance
+  - generics
+steps:
+  - introduction
+  - initialisation-du-projet
+  - refactoring-du-repository
+  - typage-generique-avec-phpstan
+  - conclusion
+---

_tutorials/fr/2023-11-22-composition-over-inheritance-et-typage-generique-avec-symfony-et-doctrine/steps/conclusion.md

@@ -0,0 +1,17 @@
+---
+contentType: tutorial-step
+tutorial: composition-over-inheritance-et-typage-generique-avec-symfony-et-doctrine
+slug: conclusion
+title: Conclusion
+---
+### Conclusion
+
+Ouf ! Et voilà ! Vous êtes arrivés au bout de ce Codelab, félicitations ! Pour rappel, vous trouverez le code de ce codelab [ici sur mon Github](https://github.com/ArthurJCQ/codelabs-compo), n'hésitez pas à y jeter un oeil.
+
+Vous êtes à présent, je l'espère, plus familier avec le concept **composition over inheritance**, et le typage générique en PHP n'a plus aucun secret pour vous.
+
+Je vous rajoute quelques sources ici qui m'ont aidé à écrire ce codelab : 
+- [PHPStan Generics](https://phpstan.org/blog/generics-in-php-using-phpdocs)
+- [Using composition over inheritance for doctrine repository in symfony](https://www.inanzzz.com/index.php/post/iyan/using-composition-over-inheritance-for-doctrine-repository-in-symfony)
+
+Merci beaucoup d'avoir suivi jusqu'ici, et à très vite !

_tutorials/fr/2023-11-22-composition-over-inheritance-et-typage-generique-avec-symfony-et-doctrine/steps/initialisation-du-projet.md

@@ -0,0 +1,70 @@
+---
+contentType: tutorial-step
+tutorial: composition-over-inheritance-et-typage-generique-avec-symfony-et-doctrine
+slug: initialisation-du-projet
+title: Initialisation du projet
+---
+### Initialisation du projet
+
+Pour commencer, initialisez un nouveau projet symfony [selon votre OS](https://symfony.com/download).
+
+Pour moi, ce sera comme cela :
+
+```bash
+$ symfony new codelabs-symfo-repo
+```
+
+À présent, installons les différentes librairies requises, en commençant par Doctrine.
+
+```bash
+$ composer require symfony/orm-pack
+```
+
+On installe le `maker` de Symfony pour aller plus vite :
+
+```bash
+$ composer require --dev symfony/maker-bundle
+```
+
+Enfin, installons PHPStan dès à présent pour plus tard.
+
+```bash
+$ composer require --dev phpstan/phpstan
+```
+
+Super, nous sommes à présent prêts à créer notre entité qui nous accompagnera tout le long de ce codelabs.
+
+Faisons simple, et créons une entité `Post` avec un `title` et un `content` avec la commande :
+
+```bash
+$ bin/console make:entity
+```
+
+Super ! Comme vous le savez, cette commande a créé une nouvelle entité ainsi que son repository, respectivement dans les dossiers `src/Entity` et `src/Repository`.
+On remarque que notre repository étend par défaut le `ServiceEntityRepository` de Doctrine, qui contient toutes les méthodes :
+
+```php
+/**
+ * @extends ServiceEntityRepository<Post>
+ *
+ * @method Post|null find($id, $lockMode = null, $lockVersion = null)
+ * @method Post|null findOneBy(array $criteria, array $orderBy = null)
+ * @method Post[]    findAll()
+ * @method Post[]    findBy(array $criteria, array $orderBy = null, $limit = null, $offset = null)
+ */
+class PostRepository extends ServiceEntityRepository
+{
+    public function __construct(ManagerRegistry $registry)
+    {
+        parent::__construct($registry, Post::class);
+    }
+
+// ...
+```
+
+<div  class="admonition note"  markdown="1"><p  class="admonition-title">Note</p>
+Notez au passage le tag <code>ServiceEntityRepository&lt;Post&gt;</code> qui est un avant-goût de ce que nous ferons plus tard avec le typage générique.
+</div>
+
+Comme on peut l'observer, notre repository est extrêmement couplé à Doctrine. Et de nombreuses méthodes que nous n'utiliserons jamais viennent polluer cette classe.
+Nous allons donc nettoyer et alléger notre repository dans la prochaine partie.

_tutorials/fr/2023-11-22-composition-over-inheritance-et-typage-generique-avec-symfony-et-doctrine/steps/introduction.md

@@ -0,0 +1,32 @@
+---
+contentType: tutorial-step
+tutorial: composition-over-inheritance-et-typage-generique-avec-symfony-et-doctrine
+slug: introduction
+title: Introduction
+---
+### Qu'allons-nous faire ?
+
+Sans doute qu'aujourd'hui, lors de l'installation d'un nouveau projet Symfony avec Doctrine, vous gardez le design de base de ces classes, avec une classe qui étend du repository de base de Doctrine, l'`EntityRepository`.
+
+Quel est le problème me diriez-vous ? Et bien tout d'abord, mettons que vous n'ayez besoin que de la méthode `find` de votre repository. Ici, vous hériterez bien de cette méthode, mais également de toutes les autres venant du repository de base de Doctrine. Ainsi, n'importe quel développeur pourrait utiliser le `getEntityManager` qui permet ensuite d'effectuer toutes les opérations de mutation (insertion, mise à jour, suppression) d'un objet dans votre base de données, et ce même si vous ne souhaitez pas que ce soit possible.
+De plus, l'`EntityManager` est un concept étroitement lié à Doctrine dans notre cas.
+Ainsi, on dira que le détail de notre implémentation (ici Doctrine et toutes ses méthodes & ses concepts) va *fuire* dans notre code métier, et ce n'est pas ce que l'on veut.
+
+Pour régler cela, nous allons utiliser l'injection de dépendance.
+
+De plus, nous aurons besoin d'être aidé par un typage plus strict pour faciliter et améliorer notre expérience de développement. Pour cela, nous utiliserons le typage générique. Comme vous le savez sûrement, ce n'est pas possible nativement en PHP de faire ce genre de typage, mais grâce à l'outil d'analyse statique PHPStan, nous contournerons ce problème.
+En cela, ce codelab est une mise en application de [cet article sur le typage générique en PHP](https://blog.eleven-labs.com/fr/typage-generique-en-php/) sorti sur le blog d'Eleven Labs. Allez y jeter un oeil !
+
+Enfin, le code source de ce codelab est disponible sur mon GitHub : 
+-   [Codelab Symfo/Doctrine](https://github.com/ArthurJCQ/codelabs-compo)
+
+
+### Pré-requis
+
+Pour les besoins de ce tutoriel il vous faudra :
+
+- Avoir PHP d'installé sur votre machine (ou via Docker si vous vous sentez plus à l'aise)
+- Avoir des bases en Symfony & Doctrine
+- Avoir lu [notre article](https://blog.eleven-labs.com/fr/typage-generique-en-php/) sur le typage générique en PHP est un plus
+
+> Le tout est développé avec PHP 8.2