Symfony Make Registration : le Tutoriel Étape par Étape

Vous voulez créer un formulaire d’inscription sur Symfony sans y passer des heures ? Vous cherchez une méthode rapide, fiable et sécurisée ? Vous avez entendu parler de la commande `make:registration-form` mais vous ne savez pas comment l’utiliser correctement ?

Ce tutoriel vous guide pas à pas pour créer un système d’inscription complet et sécurisé avec la commande make:registration-form. Oubliez le code manuel, on va droit au but pour gagner du temps et avoir un résultat qui fonctionne.

Les prérequis avant de commencer

Avant de taper la moindre commande, il faut s’assurer que votre environnement est prêt. C’est simple et rapide. Vous avez juste besoin de quelques éléments de base pour que tout se passe bien.

Voici ce qu’il vous faut :

• Un projet Symfony déjà installé et fonctionnel sur votre machine.
• Le Symfony MakerBundle doit être installé. Si ce n’est pas le cas, c’est juste une commande à lancer.
• Une base de données connectée à votre projet (vérifiez votre fichier .env).
• Une entité User qui existe déjà. C’est elle qui stockera les infos des nouveaux inscrits.

Étape 1 : La commande `make:registration-form` expliquée

Maintenant que tout est prêt, on passe à l’action. Le MakerBundle de Symfony nous offre une commande magique qui va générer tout le code nécessaire pour l’inscription. Fini le copier-coller de dizaines de fichiers, tout est automatisé.

Ouvrez votre terminal à la racine de votre projet et tapez la commande suivante :

La console va alors vous poser quelques questions. C’est un assistant qui configure le formulaire pour vous. Vos réponses sont importantes pour la suite.

Les questions de l’assistant

Voici un aperçu de ce que la commande va vous demander et comment y répondre :

• Do you want to add a @UniqueEntity validation? Répondez oui (yes). C’est une sécurité de base qui vérifie que l’adresse email n’est pas déjà utilisée dans votre users database. Sans ça, vous pourriez avoir plusieurs utilisateurs avec le même email.
• Do you want to send a verification email? Pour ce tutoriel, répondons non (no). C’est une fonctionnalité très utile, mais elle demande une configuration supplémentaire (comme le bundle `symfonycasts/verify-email-bundle`). On se concentre d’abord sur l’inscription de base.
• Do you want to automatically authenticate the user after registration? C’est à vous de voir. Si vous répondez oui (yes), l’utilisateur sera connecté directement après avoir rempli le formulaire. C’est souvent ce qu’on veut, donc c’est un bon choix par défaut.

Une fois que vous avez répondu, la commande va créer plusieurs fichiers dans votre projet. Elle vous affichera un message de succès avec la liste des fichiers générés. C’est tout, votre système d’inscription est déjà fonctionnel.

$ symfony console make:registration-form

 created: src/Controller/RegistrationController.php
 created: src/Form/RegistrationFormType.php
 created: templates/registration/register.html.twig

Success!

Next, check out your new controller and template and customize them!
Then, make sure you have a firewall setup in security.yaml that allows
anonymous users to access the URL of your registration page (e.g. /register).

Étape 2 : Analyse des fichiers générés par la commande

Symfony ne fait pas juste apparaître du code par magie. Il génère trois fichiers qui ont chacun un rôle précis. Comprendre ce qu’ils font vous permettra de les modifier plus tard si vous en avez besoin. C’est vraiment simple une fois qu’on a vu la logique.

Le contrôleur : `RegistrationController.php`

Ce fichier est le cerveau de l’opération. C’est lui qui reçoit la demande quand un utilisateur veut s’inscrire, qui affiche le formulaire et qui traite les données une fois qu’il est envoyé.

À l’intérieur, vous trouverez une méthode `register()`. Voici ce qu’elle fait, dans l’ordre :

• Elle crée une nouvelle instance de votre entité User.
• Elle crée le formulaire en se basant sur la classe `RegistrationFormType`.
• Elle gère la soumission du formulaire (`handleRequest`).
• Si le formulaire est soumis et valide, elle s’occupe du plus important :
  • Elle hache le mot de passe pour ne jamais le stocker en clair. C’est une règle de sécurité non négociable.
  • Elle sauvegarde le nouvel utilisateur dans la base de données (`persist` et `flush`).
  • Elle redirige l’utilisateur vers une autre page (par exemple, la page d’accueil).

// src/Controller/RegistrationController.php
namespace App\Controller;

use App\Entity\User;
use App\Form\RegistrationFormType;
use Doctrine\ORM\EntityManagerInterface;
use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
use Symfony\Component\Routing\Annotation\Route;

class RegistrationController extends AbstractController
{
    #[Route('/register', name: 'app_register')]
    public function register(Request $request, UserPasswordHasherInterface $userPasswordHasher, EntityManagerInterface $entityManager): Response
    {
        $user = new User();
        $form = $this->createForm(RegistrationFormType::class, $user);
        $form->handleRequest($request);

        if ($form->isSubmitted() && $form->isValid()) {
            // encode the plain password
            $user->setPassword(
                $userPasswordHasher->hashPassword(
                    $user,
                    $form->get('plainPassword')->getData()
                )
            );

            $entityManager->persist($user);
            $entityManager->flush();
            // do anything else you need here, like send an email

            return $this->redirectToRoute('app_home'); // Change to your desired route
        }

        return $this->render('registration/register.html.twig', [
            'registrationForm' => $form->createView(),
        ]);
    }
}

La classe de formulaire : `RegistrationFormType.php`

Ce fichier définit la structure de votre formulaire. C’est ici que vous décidez quels champs l’utilisateur doit remplir. Par défaut, la commande `make:registration-form` crée un champ pour l’email, un champ pour le mot de passe en clair (`plainPassword`) et une case à cocher pour accepter les conditions d’utilisation.

Le fichier contient aussi les règles de validation de base. Par exemple, il vérifie que le mot de passe n’est pas vide (`NotBlank`) et qu’il a une longueur minimale (`Length`). C’est grâce au composant Validator de Symfony.

// src/Form/RegistrationFormType.php
namespace App\Form;

// ... other use statements

class RegistrationFormType extends AbstractType
{
    public function buildForm(FormBuilderInterface $builder, array $options): void
    {
        $builder
            ->add('email')
            ->add('agreeTerms', CheckboxType::class, [
                'mapped' => false,
                'constraints' => [
                    new IsTrue([
                        'message' => 'You should agree to our terms.',
                    ]),
                ],
            ])
            ->add('plainPassword', PasswordType::class, [
                'mapped' => false,
                'attr' => ['autocomplete' => 'new-password'],
                'constraints' => [
                    new NotBlank([
                        'message' => 'Please enter a password',
                    ]),
                    new Length([
                        'min' => 6,
                        'minMessage' => 'Your password should be at least {{ limit }} characters',
                        'max' => 4096,
                    ]),
                ],
            ])
        ;
    }

    // ... configureOptions and other methods
}

Le template : `templates/registration/register.html.twig`

Enfin, ce fichier est la partie visible de l’iceberg. C’est le code HTML et Twig qui affiche le formulaire dans le navigateur. Il utilise les fonctions de formulaire de Twig (`form_start`, `form_widget`, `form_end`) pour générer les champs, les labels et les messages d’erreur.

Ce fichier est très simple. Vous pouvez le modifier pour l’adapter au design de votre site. Vous pouvez par exemple changer la structure, ajouter des classes CSS ou réorganiser les champs comme vous le voulez.

{# templates/registration/register.html.twig #}
{% extends 'base.html.twig' %}

{% block title %}Register{% endblock %}

{% block body %}
    

    {{ form_errors(registrationForm) }}

    {{ form_start(registrationForm) }}
        {{ form_row(registrationForm.email) }}
        {{ form_row(registrationForm.plainPassword, {
            label: 'Password'
        }) }}
        {{ form_row(registrationForm.agreeTerms) }}

        Register
    {{ form_end(registrationForm) }}
{% endblock %}

Étape 3 : Personnaliser le formulaire d’inscription

Le formulaire de base est bien, mais il est rare qu’il suffise. Souvent, on veut demander plus d’informations à l’utilisateur, comme son nom et son prénom. C’est très simple d’ajouter des champs au formulaire généré. Il suffit de suivre quatre étapes logiques.

On va voir comment ajouter les champs `firstName` et `lastName`.

1. Modifier l’entité `User`

   La première chose à faire est d’ajouter les nouvelles propriétés à votre `User class`. Ouvrez `src/Entity/User.php` et ajoutez `firstName` et `lastName` avec leurs getters et setters.

   
   // src/Entity/User.php
   // ...
   #[ORM\Column(length: 255)]
   private ?string $firstName = null;
   
   #[ORM\Column(length: 255)]
   private ?string $lastName = null;
   
   // ... N'oubliez pas de générer les getters et setters
   public function getFirstName(): ?string
   {
       return $this->firstName;
   }
   
   public function setFirstName(string $firstName): static
   {
       $this->firstName = $firstName;
       return $this;
   }
   // ... idem pour lastName
           

2. Mettre à jour la base de données

   Votre entité a changé, mais pas votre base de données. Il faut synchroniser les deux. Pour ça, on utilise Doctrine Migrations.

   
   # 1. Créer le fichier de migration
   symfony console make:migration
   
   # 2. Appliquer la migration à la base de données
   symfony console doctrine:migrations:migrate
           

3. Ajouter les champs dans `RegistrationFormType.php`

   Maintenant, il faut dire à Symfony d’afficher ces nouveaux champs dans le formulaire. Ouvrez `src/Form/RegistrationFormType.php` et ajoutez les champs `firstName` et `lastName` dans la méthode `buildForm`.

   
   // src/Form/RegistrationFormType.php
   // ...
   public function buildForm(FormBuilderInterface $builder, array $options): void
   {
       $builder
           ->add('firstName') // Nouveau champ
           ->add('lastName')  // Nouveau champ
           ->add('email')
           // ... reste du formulaire
       ;
   }
           

   Vous pouvez en apprendre plus sur le fonctionnement du composant Form ou voir comment ajouter des contraintes de validation (par exemple, pour rendre ces champs obligatoires).

4. Afficher les champs dans le template Twig

   La dernière étape est de s’assurer que les champs s’affichent correctement. Ouvrez `templates/registration/register.html.twig`. Si vous utilisez `form_widget(registrationForm)`, les champs apparaîtront automatiquement. Si vous affichez chaque champ manuellement avec `form_row`, ajoutez les nouvelles lignes.

   
   {# templates/registration/register.html.twig #}
   // ...
   {{ form_start(registrationForm) }}
       {{ form_row(registrationForm.firstName) }} {# Nouvelle ligne #}
       {{ form_row(registrationForm.lastName) }}  {# Nouvelle ligne #}
       {{ form_row(registrationForm.email) }}
       {{ form_row(registrationForm.plainPassword, {
           label: 'Password'
       }) }}
       // ...
   {{ form_end(registrationForm) }}
   // ...
           

Et voilà. Rechargez votre page `/register`, et vous verrez les champs pour le nom et le prénom apparaître. Les données seront automatiquement liées à votre `user object` et sauvegardées.

Bonnes Pratiques et Sécurité : Aller plus loin

Utiliser une commande automatique, c’est bien, mais il faut être sûr que le résultat est sécurisé. Avec Symfony, vous pouvez être tranquille. La solution générée par `make:registration-form` intègre par défaut des mécanismes de sécurité robustes qui protègent votre application et vos utilisateurs.

Le point le plus critique est le hachage de mot de passe. Le contrôleur utilise le service `UserPasswordHasherInterface` pour transformer le mot de passe de l’utilisateur en une chaîne de caractères complexe et irréversible avant de le stocker. C’est le standard de l’industrie. Même si votre base de données est compromise, les mots de passe ne pourront pas être lus.

• PasswordHasher : La configuration du hachage se trouve dans `config/packages/security.yaml`. Symfony choisit automatiquement l’algorithme le plus sûr disponible sur votre serveur (comme `bcrypt` ou `argon2i`).
• Protection CSRF : Vos formulaires sont automatiquement protégés contre les attaques de type Cross-Site Request Forgery. Symfony ajoute un jeton caché dans chaque formulaire et vérifie sa présence à la soumission. Vous n’avez rien à faire, c’est activé par défaut.

FAQ – Symfony Registration Form

Comment connecter automatiquement l’utilisateur après son inscription ?

Si vous n’avez pas dit « oui » à la question lors de l’exécution de la commande, vous devez le faire manuellement. Le plus simple est d’utiliser le système d’authentification de Symfony. Après avoir sauvegardé l’utilisateur (`$entityManager->flush()`), vous pouvez utiliser le `LoginLinkAuthenticator` ou un `GuardAuthenticator` pour créer une session pour le nouvel utilisateur.

Comment mettre en place la vérification par email ?

C’est une étape essentielle pour vérifier que l’adresse email est valide. Le meilleur outil pour ça est le bundle `symfonycasts/verify-email-bundle`. Il s’intègre parfaitement avec le formulaire d’inscription et gère la création de liens sécurisés à usage unique et leur validation.

Comment traduire les messages d’erreur de validation ?

Pour traduire des messages comme « Please enter a password », vous devez utiliser le composant Translation de Symfony. Vous créez des fichiers de traduction (par exemple en format YAML ou XLIFF) dans le dossier `translations/` de votre projet, et Symfony s’occupera d’afficher le bon message en fonction de la langue de l’utilisateur.

Vous l’avez vu, la commande `symfony console make:registration-form` est un outil puissant pour démarrer. Elle crée une base solide, sécurisée et fonctionnelle en quelques secondes. Vous gagnez un temps précieux et vous pouvez vous concentrer sur l’ajout de fonctionnalités spécifiques à votre projet.

Maintenant que votre système d’inscription est en place, l’étape logique suivante est de créer un formulaire de connexion. Heureusement, le MakerBundle a aussi une commande pour ça : `make:auth`. C’est tout aussi simple et rapide.