Eloquent — ORM Laravel 12

php artisan make:model User           # simple
php artisan make:model Post -mf       # + migration + factory
php artisan make:model Comment -mfs   # + seeder

<?php
// app/Models/User.php
namespace App\Models;
 
use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Foundation\Auth\User as Authenticatable;
 
class User extends Authenticatable
{
    use HasFactory;
 
    protected $fillable = ['name', 'email', 'password'];
    protected $hidden = ['password', 'remember_token'];
    protected $casts = [
        'email_verified_at' => 'datetime',
        'is_active' => 'boolean',
        'settings' => 'array',
    ];
}

$user = User::create([
    'name' => 'John Doe',
    'email' => 'john@example.com',
    'password' => bcrypt('password'),
]);
 
$user = User::firstOrCreate(
    ['email' => 'john@example.com'],
    ['name' => 'John Doe']
);

$user = User::find(1);
$user = User::where('email', 'john@example.com')->first();
$user = User::findOrFail(1);  // 404 si non trouvé
 
$users = User::where('active', true)
    ->orderBy('name')
    ->paginate(10);
 
User::chunk(200, function ($users) {
    // Traiter par lots
});

$user = User::find(1);
$user->update(['name' => 'Updated']);
 
User::where('active', false)->update(['active' => true]);
 
User::updateOrCreate(
    ['email' => 'john@example.com'],
    ['name' => 'John Updated']
);

$user = User::find(1);
$user->delete();
 
User::destroy(1);
User::destroy([1, 2, 3]);
 
User::where('active', false)->delete();

// User model
public function profile(): HasOne
{
    return $this->hasOne(Profile::class);
}
 
// Profile model  
public function user(): BelongsTo
{
    return $this->belongsTo(User::class);
}
 
// Usage
$profile = User::find(1)->profile;

// Post model
public function comments(): HasMany
{
    return $this->hasMany(Comment::class);
}
 
// Comment model
public function post(): BelongsTo
{
    return $this->belongsTo(Post::class);
}
 
// Usage
$comments = Post::find(1)->comments;
$approved = $post->comments()->where('approved', true)->get();

// User model
public function roles(): BelongsToMany
{
    return $this->belongsToMany(Role::class);
}
 
// Usage
$user = User::find(1);
$roles = $user->roles;
 
$user->roles()->attach($roleId);
$user->roles()->detach($roleId);
$user->roles()->sync([1, 2, 3]);
 
// Avec pivot data
$user->roles()->attach($roleId, ['expires_at' => now()]);

// Comment model
public function commentable(): MorphTo
{
    return $this->morphTo();
}
 
// Post model
public function comments(): MorphMany
{
    return $this->morphMany(Comment::class, 'commentable');
}
 
// Usage
$comment = Comment::find(1);
$commentable = $comment->commentable;  // Post ou Video

User::where('active', true)->get();
User::where('votes', '>=', 100)->get();
User::where('active', true)->orWhere('votes', '>=', 100)->get();
User::whereIn('id', [1, 2, 3])->get();
User::whereBetween('votes', [100, 200])->get();
User::whereNull('deleted_at')->get();
User::whereDate('created_at', '2023-01-01')->get();

User::join('posts', 'users.id', '=', 'posts.user_id')
    ->select('users.*', 'posts.title')
    ->get();
 
User::leftJoin('profiles', 'users.id', '=', 'profiles.user_id')
    ->get();

// Dans le model
public function scopeActive(Builder $query): Builder
{
    return $query->where('active', true);
}
 
public function scopePopular(Builder $query, int $threshold = 100): Builder
{
    return $query->where('votes', '>=', $threshold);
}
 
// Usage
$activeUsers = User::active()->get();
$popularUsers = User::popular(200)->get();

// Accessor
public function getFullNameAttribute(): string
{
    return "{$this->first_name} {$this->last_name}";
}
 
// Mutator
public function setPasswordAttribute(string $value): void
{
    $this->attributes['password'] = bcrypt($value);
}
 
// Usage
echo $user->full_name;  // Appelle l'accessor
$user->password = 'plain';  // Hashé automatiquement

// Éviter le problème N+1
$posts = Post::with('user')->get();  // 2 requêtes
$posts = Post::with(['user', 'comments'])->get();
$posts = Post::with('user.profile')->get();
 
// Avec conditions
$posts = Post::with(['comments' => function ($query) {
    $query->where('approved', true);
}])->get();
 
// Lazy loading
$posts = Post::all();
$posts->load('user');
 
// Prévenir le lazy loading
Model::preventLazyLoading(! app()->environment('production'));

$users = User::all();
 
$activeUsers = $users->filter(fn ($user) => $user->active);
$userNames = $users->map(fn ($user) => $user->name);
$totalVotes = $users->reduce(fn ($carry, $user) => $carry + $user->votes, 0);
$usersByRole = $users->groupBy('role');
$sortedUsers = $users->sortBy('name');
$uniqueEmails = $users->unique('email');
$userNames = $users->pluck('name');

use Illuminate\Database\Eloquent\SoftDeletes;
 
class User extends Model
{
    use SoftDeletes;
}
 
$user->delete();        // Soft delete
$user->restore();       // Restaurer
$user->forceDelete();    // Suppression définitive
 
User::withTrashed()->get();     // Inclure soft deleted
User::onlyTrashed()->get();    // Seulement soft deleted