Manipuler l'ORM Eloquent

Manipuler l'ORM Eloquent | Med Learning

Leçon 1

Le principe d'un ORM

Sans ORM (SQL)	Avec Eloquent
`SELECT * FROM livres WHERE id = 3`	`Livre::find(3)`
`INSERT INTO auteurs (nom, ...) VALUES (...)`	`Auteur::create(['nom' => 'Leïla Slimani'])`
`UPDATE livres SET prix = 59 WHERE id = 3`	`$livre->update(['prix' => 59])`
jointure livres ↔ categories	`$livre->categorie->libelle`

Leçon 2

Créer un modèle

Option	Génère aussi
`-m` (`--migration`)	la migration `create_livres_table`
`-f` (`--factory`)	la fabrique `LivreFactory`
`-s` (`--seed`)	le seeder `LivreSeeder`
`-c` (`--controller`)	le contrôleur `LivreController` (avec `-r` : de ressource)
`--policy`	la policy `LivrePolicy` (chapitre 12)

Leçon 3

Lire des enregistrements

Leçon 4

Créer, modifier, supprimer

Leçon 5

Transformer les attributs

Cast	Résultat en PHP
`integer`, `float`, `boolean`, `string`	le type correspondant
`decimal:2`	une chaîne avec 2 décimales (précis pour l'argent)
`date`, `datetime`, `immutable_date`	un objet Carbon (`->format()`, `->diffForHumans()`)
`array`, `collection`, `object`	une colonne JSON lue comme tableau, collection ou objet
`Langue::class` (énumération)

Leçon 6

Les portées (scopes)

Leçon 7

Les collections

Leçon 8

Les relations

Relation	Dans le modèle qui…	Méthode
un à un	n'a pas la clé étrangère	`hasOne(Profil::class)`
un à plusieurs	n'a pas la clé étrangère (le « un »)	`hasMany(Livre::class)`
inverse d'un à un / un à plusieurs	a la clé étrangère	`belongsTo(Categorie::class)`
plusieurs à plusieurs

Leçon 9

La sérialisation

Leçon 10

Le modèle Livre complet et le CRUD de Kitab

Leçon 11

Les vidéos du chapitre

Vidéo · À regarder

30 Days to Learn Laravel - Complete 8 Hour Course

Laracasts (Jeffrey Way) · YouTube

Regarde de 1:43:51 à 2:02:0818 min 17 s

Ouvrir sur YouTube à 1:43:51

Vidéo · À regarder

30 Days to Learn Laravel - Complete 8 Hour Course

Laracasts (Jeffrey Way) · YouTube

Regarde de 2:21:25 à 2:29:13

Travaux pratiques

TP fil rouge · Le catalogue et l'administration avec Eloquent

Exercices

Exercice 11.1

Choisis la bonne réponse

1Le modèle Auteur correspond par défaut à la table…
2Livre::create($donnees) ignore une colonne si elle…
3findOrFail(99) sur un id inexistant provoque…
4Avec SoftDeletes, $livre->delete()…
5Dans Livre, la relation vers sa catégorie est…
6$livre->auteurs()->sync([1, 4])…
7$livre->auteurs (sans parenthèses) renvoie…
8Pour éviter le problème N+1, on utilise…

0/8 répondues

Exercice 11.2

Eloquent ou Query Builder ?

Exercice 11.3

Les relations de Kitab

L'essentiel du chapitre

À retenir

ORM Eloquent (Active Record) : un modèle par table (app/Models), une ligne = un objet. make:model Livre -mfsc (ou -a).
Conventions : table = pluriel anglais snake case (Livre → livres ; attention aux mots comme Avis), clé id, created_at/updated_at ; sinon $table, $primaryKey, $timestamps (ou attributs Laravel 13 #[Table]).
Lire : all, get, find, findOrFail, first, firstOrFail, + tout le Query Builder ; chunk, cursor.
Écrire : new + save(), create() (affectation de masse protégée par $fillable / $guarded), update(), firstOrCreate, updateOrCreate, increment ; delete, destroy ; SoftDeletes (withTrashed, onlyTrashed, restore, forceDelete).
casts() : integer, decimal:2, date (Carbon), array, énumération, hashed, encrypted. Accesseurs/mutateurs : Attribute::make(get:, set:), $appends. Événements dans booted().
Portées : scopeNom(Builder $query) → Livre::nom() (ou #[Scope] depuis Laravel 12). Collections : count, sum, avg, pluck, filter, map, sortBy, groupBy, keyBy… ; filtrer en base, pas en PHP.

Convention	Valeur par défaut	Pour changer
nom de la table	le nom de la classe en snake case et au pluriel anglais : `Livre` → `livres`, `Categorie` → `categories`, `LigneCommande` → `ligne_commandes`	`protected $table = 'lignes';`
clé primaire	colonne `id`, entier auto-incrémenté	`protected $primaryKey = 'isbn';` + `public $incrementing = false;` + `protected $keyType = 'string';`
horodatage	colonnes `created_at` et `updated_at` remplies automatiquement	`public $timestamps = false;`
connexion	celle du `.env`	`protected $connection = 'mysql2';`

Exercice 11.4

Chasser les N+1

Cette page affiche 20 commandes avec le nom du client et les titres des livres. Combien de requêtes envoie-t-elle ? Corrige-la pour qu'elle en envoie 3.

php

$commandes = Commande::latest()->take(20)->get();
foreach ($commandes as $commande) {
    echo $commande->client->name . ' : ' . $commande->livres->pluck('titre')->join(', ');
}

bash

php artisan make:model Livre
php artisan make:model Livre -mfsc        # + migration, fabrique, seeder, contrôleur
php artisan make:model Livre -a           # + tout : migration, fabrique, seeder, policy, contrôleur de ressource, form requests

php

use App\Models\Livre;

$livres = Livre::all();                                   // tous les livres (Collection de Livre)
$livres = Livre::where('langue', 'fr')->orderBy('titre')->get();
$livre  = Livre::find(3);                                 // par clé primaire, ou null
$livre  = Livre::findOrFail(3);                           // ou erreur 404
$livre  = Livre::where('slug', $slug)->first();           // le premier, ou null
$livre  = Livre::where('slug', $slug)->firstOrFail();     // ou erreur 404
$livres = Livre::find([1, 2, 3]);                         // plusieurs par clé

$nb     = Livre::where('stock', 0)->count();
$max    = Livre::max('prix');
$titres = Livre::pluck('titre', 'id');
$page   = Livre::latest()->paginate(12);

php

// 1. instancier, remplir, enregistrer
$auteur = new Auteur();
$auteur->nom = 'Leïla Slimani';
$auteur->nationalite = 'marocaine';
$auteur->save();                    // INSERT ; $auteur->id est rempli

// 2. en une ligne, par affectation de masse
$auteur = Auteur::create(['nom' => 'Abdellatif Laâbi', 'nationalite' => 'marocaine']);

// 3. chercher ou créer
$categorie = Categorie::firstOrCreate(['slug' => 'poesie'], ['libelle' => 'Poésie']);
$livre = Livre::updateOrCreate(['isbn' => $isbn], ['stock' => 12]);   // modifier ou créer

php

$livre = Livre::findOrFail(3);
$livre->prix = 59.90;
$livre->save();                                  // UPDATE (updated_at est mis à jour)

$livre->update(['prix' => 59.90, 'stock' => 8]); // affectation de masse

Livre::where('categorie_id', 2)->update(['prix' => 0]);   // plusieurs lignes à la fois (sans événements)
$livre->increment('stock', 5);
$livre->decrement('stock');

$livre->titre = 'Nouveau titre';
$livre->isDirty('titre');        // true : modifié mais pas encore enregistré

php

use Illuminate\Database\Eloquent\SoftDeletes;

class Livre extends Model
{
    use SoftDeletes;
}

$livre->delete();                                  // remplit deleted_at
Livre::all();                                      // n'inclut plus ce livre
Livre::withTrashed()->get();                       // inclut les livres supprimés
Livre::onlyTrashed()->get();                       // seulement la corbeille
$livre->trashed();                                 // true
$livre->restore();                                 // restaure
$livre->forceDelete();                             // supprime vraiment

app/Models/Livre.php (extrait)

php

use App\Enums\Langue;

protected function casts(): array
{
    return [
        'prix' => 'decimal:2',        // chaîne avec 2 décimales : "65.00"
        'stock' => 'integer',
        'publie_le' => 'date',        // objet Carbon : $livre->publie_le->format('d/m/Y')
        'langue' => Langue::class,    // énumération : $livre->langue->libelle()
        'options' => 'array',         // JSON ↔ tableau PHP
    ];
}

app/Models/Livre.php (extrait)

php

use Illuminate\Database\Eloquent\Builder;

public function scopeDisponibles(Builder $query): void
{
    $query->where('stock', '>', 0);
}

public function scopeEnLangue(Builder $query, string $langue): void
{
    $query->where('langue', $langue);
}

php

$livres = Livre::with('categorie')->get();

$livres->count();                                  // nombre
$livres->sum('stock');                             // somme d'une colonne
$livres->avg('prix');                              // moyenne
$livres->pluck('titre');                           // les titres
$livres->first();                                  // le premier
$livres->filter(fn ($l) => $l->stock === 0);       // les épuisés
$livres->map(fn ($l) => strtoupper($l->titre));    // transformer chaque élément
$livres->sortByDesc('prix');                       // trier
$livres->groupBy('langue');                        // ['fr' => [...], 'ar' => [...]]
$livres->keyBy('isbn');                            // indexer par ISBN
$livres->contains('isbn', '9782070612758');        // présence
$livres->isEmpty();                                // vide ?
$livres->each(fn ($l) => $l->increment('stock'));  // action sur chacun
$livres->take(3);                                  // les 3 premiers

Les modèles de Kitab et leurs relations

plantuml

@startuml
class User {
  name
  email
  role
}
class Commande {
  numero
  statut
  total
}
class Livre {
  isbn
  titre
  slug
  prix
  stock
  langue
}
class Categorie {
  libelle
  slug
}
class Auteur {
  nom
  nationalite
}
User "1" -- "0..*" Commande : hasMany / belongsTo
Commande "0..*" -- "1..*" Livre : belongsToMany\n(commande_livre : quantite, prix_unitaire)
Categorie "1" -- "0..*" Livre : hasMany / belongsTo
Livre "0..*" -- "1..*" Auteur : belongsToMany\n(auteur_livre)
Categorie "0..1" -- "0..*" Categorie : parent / enfants
@enduml

app/Models/Categorie.php

php

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\HasMany;

class Categorie extends Model
{
    use HasFactory;

    protected $fillable = ['libelle', 'slug', 'parent_id'];

    public function livres(): HasMany
    {
        return $this->hasMany(Livre::class);          // clé étrangère devinée : categorie_id
    }

    public function parent(): BelongsTo
    {
        return $this->belongsTo(Categorie::class, 'parent_id');
    }

    public function enfants(): HasMany
    {
        return $this->hasMany(Categorie::class, 'parent_id');
    }
}

php

// dans Livre
public function auteurs(): BelongsToMany
{
    return $this->belongsToMany(Auteur::class);      // table pivot devinée : auteur_livre
}
// dans Auteur
public function livres(): BelongsToMany
{
    return $this->belongsToMany(Livre::class);
}

php

class User extends Authenticatable
{
    protected $hidden = ['password', 'remember_token'];   // jamais dans le JSON
}

class Livre extends Model
{
    protected $appends = ['prix_formate'];                // ajoute l'accesseur au JSON
}

app/Enums/Langue.php

php

<?php

namespace App\Enums;

enum Langue: string
{
    case Arabe = 'ar';
    case Francais = 'fr';
    case Anglais = 'en';

    public function libelle(): string
    {
        return match ($this) {
            self::Arabe => 'Arabe',
            self::Francais => 'Français',
            self::Anglais => 'Anglais',
        };
    }
}

app/Models/Livre.php

php

<?php

namespace App\Models;

use App\Enums\Langue;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Casts\Attribute;
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Database\Eloquent\Relations\BelongsToMany;
use Illuminate\Database\Eloquent\SoftDeletes;
use Illuminate\Support\Str;

class Livre extends Model
{
    use HasFactory, SoftDeletes;

    protected $fillable = [
        'isbn', 'titre', 'slug', 'resume', 'prix', 'stock',
        'langue', 'couverture', 'publie_le', 'categorie_id',
    ];

    protected function casts(): array
    {
        return [
            'prix' => 'decimal:2',
            'stock' => 'integer',
            'publie_le' => 'date',
            'langue' => Langue::class,
        ];
    }

    protected static function booted(): void
    {
        static::creating(function (Livre $livre) {
            $livre->slug ??= Str::slug($livre->titre);
        });
    }

    public function getRouteKeyName(): string
    {
        return 'slug';
    }

    // Relations
    public function categorie(): BelongsTo
    {
        return $this->belongsTo(Categorie::class);
    }

    public function auteurs(): BelongsToMany
    {
        return $this->belongsToMany(Auteur::class);
    }

    public function commandes(): BelongsToMany
    {
        return $this->belongsToMany(Commande::class)->withPivot('quantite', 'prix_unitaire');
    }

    // Portées
    public function scopeDisponibles(Builder $query): void
    {
        $query->where('stock', '>', 0);
    }

    public function scopeRecherche(Builder $query, ?string $texte): void
    {
        $query->when($texte, fn ($q) => $q->where(function ($q) use ($texte) {
            $q->whereLike('titre', "%{$texte}%")
              ->orWhereHas('auteurs', fn ($a) => $a->whereLike('nom', "%{$texte}%"));
        }));
    }

    // Accesseurs
    protected function prixFormate(): Attribute
    {
        return Attribute::make(get: fn () => number_format((float) $this->prix, 2, ',', ' ') . ' DH');
    }

    protected function couvertureUrl(): Attribute
    {
        return Attribute::make(
            get: fn () => $this->couverture ? asset('storage/' . $this->couverture) : asset('images/sans-couverture.png'),
        );
    }
}

app/Http/Controllers/Admin/LivreController.php

php

<?php

namespace App\Http\Controllers\Admin;

use App\Http\Controllers\Controller;
use App\Http\Requests\StoreLivreRequest;
use App\Http\Requests\UpdateLivreRequest;
use App\Models\Auteur;
use App\Models\Categorie;
use App\Models\Livre;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\DB;
use Illuminate\Support\Facades\Storage;
use Illuminate\View\View;

class LivreController extends Controller
{
    public function index(Request $request): View
    {
        $livres = Livre::with(['categorie', 'auteurs'])
            ->recherche($request->input('q'))
            ->orderBy('titre')
            ->paginate(15)
            ->withQueryString();

        return view('admin.livres.index', compact('livres'));
    }

    public function create(): View
    {
        return view('admin.livres.create', [
            'categories' => Categorie::orderBy('libelle')->get(),
            'auteurs' => Auteur::orderBy('nom')->get(),
        ]);
    }

    public function store(StoreLivreRequest $request): RedirectResponse
    {
        $donnees = $request->safe()->except(['auteurs', 'couverture']);

        if ($request->hasFile('couverture')) {
            $donnees['couverture'] = $request->file('couverture')->store('couvertures', 'public');
        }

        DB::transaction(function () use ($donnees, $request) {
            $livre = Livre::create($donnees);
            $livre->auteurs()->sync($request->validated('auteurs'));
        });

        return to_route('admin.livres.index')->with('status', 'Livre ajouté.');
    }

    public function show(Livre $livre): View
    {
        $livre->load(['categorie', 'auteurs']);
        return view('admin.livres.show', compact('livre'));
    }

    public function edit(Livre $livre): View
    {
        return view('admin.livres.edit', [
            'livre' => $livre->load('auteurs'),
            'categories' => Categorie::orderBy('libelle')->get(),
            'auteurs' => Auteur::orderBy('nom')->get(),
        ]);
    }

    public function update(UpdateLivreRequest $request, Livre $livre): RedirectResponse
    {
        $donnees = $request->safe()->except(['auteurs', 'couverture']);

        if ($request->hasFile('couverture')) {
            if ($livre->couverture) {
                Storage::disk('public')->delete($livre->couverture);
            }
            $donnees['couverture'] = $request->file('couverture')->store('couvertures', 'public');
        }

        $livre->update($donnees);
        $livre->auteurs()->sync($request->validated('auteurs'));

        return to_route('admin.livres.index')->with('status', 'Livre modifié.');
    }

    public function destroy(Livre $livre): RedirectResponse
    {
        $livre->delete();     // suppression douce : la couverture est gardée pour une éventuelle restauration

        return to_route('admin.livres.index')->with('status', "« {$livre->titre} » a été supprimé.");
    }
}

resources/views/admin/livres/index.blade.php (extrait)

blade

<table>
    <thead><tr><th>Titre</th><th>Auteurs</th><th>Catégorie</th><th>Prix</th><th>Stock</th><th></th></tr></thead>
    <tbody>
        @forelse ($livres as $livre)
            <tr>
                <td>{{ $livre->titre }}</td>
                <td>{{ $livre->auteurs->pluck('nom')->join(', ') }}</td>
                <td>{{ $livre->categorie->libelle }}</td>
                <td>{{ $livre->prix_formate }}</td>
                <td>{{ $livre->stock }}</td>
                <td>
                    <a href="{{ route('admin.livres.edit', $livre) }}">Modifier</a>
                    <form method="POST" action="{{ route('admin.livres.destroy', $livre) }}" onsubmit="return confirm('Supprimer ce livre ?')">
                        @csrf
                        @method('DELETE')
                        <button type="submit">Supprimer</button>
                    </form>
                </td>
            </tr>
        @empty
            <tr><td colspan="6">Aucun livre.</td></tr>
        @endforelse
    </tbody>
</table>
{{ $livres->links() }}

resources/views/admin/livres/edit.blade.php (extrait : la catégorie et les auteurs)

blade

<form method="POST" action="{{ route('admin.livres.update', $livre) }}" enctype="multipart/form-data">
    @csrf
    @method('PUT')

    <label for="categorie_id">Catégorie</label>
    <select id="categorie_id" name="categorie_id">
        @foreach ($categories as $categorie)
            <option value="{{ $categorie->id }}" @selected(old('categorie_id', $livre->categorie_id) == $categorie->id)>
                {{ $categorie->libelle }}
            </option>
        @endforeach
    </select>

    <fieldset>
        <legend>Auteurs</legend>
        @foreach ($auteurs as $auteur)
            <label>
                <input type="checkbox" name="auteurs[]" value="{{ $auteur->id }}"
                       @checked(in_array($auteur->id, old('auteurs', $livre->auteurs->pluck('id')->all())))>
                {{ $auteur->nom }}
            </label>
        @endforeach
    </fieldset>
    @error('auteurs') <p class="message-erreur">{{ $message }}</p> @enderror

    <button type="submit">Enregistrer</button>
</form>

app/Models/Auteur.php : un modèle minimal

php

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Auteur extends Model
{
    use HasFactory;

    protected $fillable = ['nom', 'nationalite', 'date_naissance'];
}

app/Models/Livre.php (extrait)

php

use Illuminate\Database\Eloquent\Casts\Attribute;
use Illuminate\Support\Str;

/** Accesseur calculé : $livre->prix_formate */
protected function prixFormate(): Attribute
{
    return Attribute::make(
        get: fn () => number_format((float) $this->prix, 2, ',', ' ') . ' DH',
    );
}

/** Accesseur et mutateur : le titre est nettoyé à l'écriture */
protected function titre(): Attribute
{
    return Attribute::make(
        get: fn (string $valeur) => $valeur,
        set: fn (string $valeur) => Str::squish($valeur),   // supprime les espaces en trop
    );
}

app/Models/Livre.php (extrait)

php

protected static function booted(): void
{
    static::creating(function (Livre $livre) {
        $livre->slug ??= Str::slug($livre->titre);   // crée le slug s'il n'est pas fourni
    });
}

php

$livre = Livre::find(3);

$livre->categorie;              // PROPRIÉTÉ : le modèle Categorie (requête exécutée)
$livre->categorie->libelle;     // "Romans"
$livre->auteurs;                // Collection d'Auteur
$livre->auteurs->pluck('nom')->join(', ');   // "Antoine de Saint-Exupéry"

$livre->auteurs();              // MÉTHODE : un Query Builder, qu'on peut compléter
$livre->auteurs()->where('nationalite', 'marocaine')->get();

$categorie->livres()->count();  // compte en SQL, sans charger les livres

php

// créer un livre directement dans une catégorie (categorie_id est rempli automatiquement)
$categorie->livres()->create(['isbn' => '9789954000001', 'titre' => 'Le Pain nu', 'prix' => 70]);

// belongsTo : associer / dissocier
$livre->categorie()->associate($autreCategorie);
$livre->save();

// belongsToMany : gérer la table pivot
$livre->auteurs()->attach($auteurId);                 // ajouter un lien
$livre->auteurs()->attach([1, 4]);
$livre->auteurs()->detach($auteurId);                 // retirer un lien
$livre->auteurs()->sync([1, 4]);                      // garder EXACTEMENT ces liens (formulaire de modification)
$livre->auteurs()->toggle([2]);                       // ajouter si absent, retirer si présent
$commande->livres()->attach($livreId, ['quantite' => 2, 'prix_unitaire' => 65]);   // avec données pivot

php

Categorie::has('livres')->get();                               // catégories qui ont au moins un livre
Categorie::doesntHave('livres')->get();                        // catégories vides
Livre::whereHas('auteurs', fn ($q) => $q->where('nationalite', 'marocaine'))->get();  // livres d'auteurs marocains
Categorie::withCount('livres')->get();                         // ajoute $categorie->livres_count
Auteur::withCount('livres')->orderByDesc('livres_count')->take(5)->get();   // auteurs les plus publiés

Le problème N+1

php

$livres = Livre::all();                       // 1 requête
foreach ($livres as $livre) {
    echo $livre->categorie->libelle;          // 1 requête PAR livre !
}
// 100 livres = 101 requêtes

php

$livres = Livre::with('categorie')->get();            // 2 requêtes, quel que soit le nombre de livres
$livres = Livre::with(['categorie', 'auteurs'])->paginate(12);   // 3 requêtes
$livres = Livre::with('auteurs:id,nom')->get();       // seulement certaines colonnes de la relation
$livre->load('auteurs');                              // charger après coup, sur un modèle déjà lu