Voici un exemple étape par étape sur la façon de créer des objets de transfert de données (DTO) à l'aide de Données Laravel :

1. Installer le package de données Laravel

Pour commencer, installez le package spatie/laravel-data à l'aide de Composer. Ce package aide à créer des DTO et à gérer efficacement les données.

composer require spatie/laravel-data

2. Créer un objet de transfert de données (DTO)

Après avoir installé le package, nous pouvons créer une classe DTO pour gérer le transfert de données. Supposons que nous ayons une entité utilisateur et que nous souhaitions créer un DTO pour transférer les données utilisateur.

Exécutez la commande Artisan suivante pour générer une nouvelle classe DTO :

php artisan make:data UserData

Cela créera une classe UserData dans le répertoire App/Data.

3. Définir les propriétés et les types dans DTO

Maintenant, modifions la classe UserData pour définir les propriétés et les types de données que vous attendez pour votre DTO.

namespace App\Data;

use Spatie\LaravelData\Data;

class UserData extends Data
{
    public function __construct(
        public string $name,
        public string $email,
        public string $address,
        public ?string $phone = null  // Optional phone field
    ) {}
}

Explication:

• La méthode __construct attribue automatiquement les valeurs entrantes aux propriétés DTO.
• La ?string $phone = null indique que la propriété phone est facultative.

4. Utiliser DTO dans un contrôleur

Maintenant que le DTO UserData est créé, nous pouvons l'utiliser dans notre contrôleur pour gérer les données entrantes, les transformer et les transmettre entre les couches de l'application.

namespace App\Http\Controllers;

use App\Data\UserData;
use App\Models\User;
use Illuminate\Http\Request;

class UserController extends Controller
{
    public function store(Request $request)
    {
        // Validate the incoming request data
        $validatedData = $request->validate([
            'name' => 'required|string',
            'email' => 'required|email',
            'address' => 'required|string',
            'phone' => 'nullable|string',
        ]);

        // Create a UserData DTO
        $userData = UserData::from($validatedData);

        // You can now access $userData->name, $userData->email, etc.
        User::create([
            'name' => $userData->name,
            'email' => $userData->email,
            'address' => $userData->address,
            'phone' => $userData->phone,
        ]);

        return response()->json(['message' => 'User created successfully']);
    }
}

Explication:

• La méthode UserData::from() mappe automatiquement les données de requête validées dans l'objet DTO.
• L'objet DTO peut désormais être utilisé pour transférer des données entre le contrôleur et le modèle (ou d'autres couches de l'application).

5. Transformer les données à l'aide de DTO

Vous pouvez également utiliser le DTO pour transformer les données lors du renvoi des réponses. Modifions la méthode show dans UserController pour renvoyer les données utilisateur via le DTO.

public function show(User $user)
{
    // Convert the User model to UserData DTO
    $userData = new UserData(
        name: $user->name,
        email: $user->email,
        address: $user->address,
        phone: $user->phone
    );

    return response()->json($userData);
}

Explication:

• Ici, nous créons manuellement un DTO UserData en transmettant les propriétés du modèle User dans le constructeur DTO.
• Ce DTO peut être renvoyé directement sous forme de réponse JSON, garantissant un format de données structuré.

6. DTO avec collections

Si vous travaillez avec des collections de données, par exemple pour récupérer une liste d'utilisateurs, le package DTO fournit également une méthode simple pour gérer les collections.

public function index()
{
    $users = User::all();

    // Convert the collection of User models to a collection of UserData DTOs
    $userCollection = UserData::collection($users);

    return response()->json($userCollection);
}

Explication:

• La méthode UserData::collection($users) mappe chaque modèle User au DTO UserData, transformant l'intégralité de la collection en une liste de DTO.

7. Personnaliser la transformation des données

Le package spatie/laravel-data permet de personnaliser la transformation, par exemple en renommant des attributs ou en ajoutant des champs calculés.

class UserData extends Data
{
    public function __construct(
        public string $name,
        public string $email,
        public string $address,
        public ?string $phone = null
    ) {}

    // Add a custom method to compute a full contact string
    public function fullContact(): string
    {
        return "{$this->name} ({$this->email})";
    }
}

Maintenant, vous pouvez utiliser fullContact() pour obtenir une chaîne formatée personnalisée lorsque vous travaillez avec ce DTO.

8. Validation des données et DTO

Vous pouvez ajouter des règles de validation directement dans le DTO à l'aide de la fonctionnalité Règles de Laravel Data.

namespace App\Data;

use Spatie\LaravelData\Attributes\Validation\Email;
use Spatie\LaravelData\Attributes\Validation\Required;
use Spatie\LaravelData\Data;

class UserData extends Data
{
    public function __construct(
        #[Required] public string $name,
        #[Email] public string $email,
        public string $address,
        public ?string $phone = null
    ) {}
}

Explication:

• Avec des attributs de validation tels que #[Required] et #[Email], vous pouvez appliquer la validation directement au niveau DTO, rationalisant encore davantage le processus.

Conclusion

Dans ce didacticiel pratique, nous avons exploré comment créer et utiliser des objets de transfert de données (DTO) à l'aide de Laravel Data. Avec le modèle DTO, vous pouvez gérer et transformer proprement vos données, garantissant la séparation des préoccupations entre les couches de votre application, tout en facilitant la maintenance du code. Le package spatie/laravel-data simplifie la gestion des DTO, offrant des fonctionnalités faciles à utiliser pour les développeurs et les applications à grande échelle.