📋 Table of Contents

1. Introduction to Eloquent ORM
2. One to One — hasOne / belongsTo
3. One to Many — hasMany / belongsTo
4. Many to Many — belongsToMany
5. Has One Through
6. Has One of Many
7. Has Many Through
8. Polymorphic: One to One
9. Polymorphic: One to Many
10. Polymorphic: Many to Many
11. Summary Reference Table
12. Quiz — Test Your Knowledge

// database/migrations/xxxx_create_users_table.php
public function up(): void
{
    Schema::create('users', function (Blueprint $table) {
        $table->id();
        $table->string('name');
        $table->string('email')->unique();
        $table->timestamps();
    });
}

// database/migrations/xxxx_create_profiles_table.php
public function up(): void
{
    Schema::create('profiles', function (Blueprint $table) {
        $table->id();
        $table->foreignId('user_id')->constrained()->cascadeOnDelete();
        $table->text('bio')->nullable();
        $table->string('avatar')->nullable();
        $table->string('phone')->nullable();
        $table->timestamps();
    });
}

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Relations\HasOne;

class User extends Model
{
    protected $fillable = ['name', 'email'];

    /**
     * User has ONE profile.
     * FK: profiles.user_id → users.id
     */
    public function profile(): HasOne
    {
        return $this->hasOne(Profile::class);
        // Override keys if needed:
        // return $this->hasOne(Profile::class, 'user_id', 'id');
    }
}

use Illuminate\Database\Eloquent\Relations\BelongsTo;

class Profile extends Model
{
    protected $fillable = ['user_id', 'bio', 'avatar', 'phone'];

    /**
     * Profile BELONGS TO one user. (Inverse side)
     */
    public function user(): BelongsTo
    {
        return $this->belongsTo(User::class);
    }
}

// ── READ ────────────────────────────────────────────────────
$user = User::find(1);
$profile = $user->profile;        // dynamic property → runs query once
echo $profile->bio;

// Eager load (avoids N+1 problem when looping many users)
$users = User::with('profile')->get();

// ── CREATE ───────────────────────────────────────────────────
$user->profile()->create([
    'bio'    => 'Full-stack Laravel developer',
    'avatar' => 'avatar.png',
]);

// ── UPDATE ───────────────────────────────────────────────────
$user->profile()->update(['bio' => 'Updated bio']);

// ── DELETE ───────────────────────────────────────────────────
$user->profile->delete();

// ── INVERSE: from profile back to user ───────────────────────
$profile = Profile::find(1);
echo $profile->user->name;        // "John Doe"

Schema::create('posts', function (Blueprint $table) {
    $table->id();
    $table->foreignId('user_id')->constrained()->cascadeOnDelete();
    $table->string('title');
    $table->longText('body');
    $table->string('status')->default('draft');
    $table->timestamps();
});

Schema::create('comments', function (Blueprint $table) {
    $table->id();
    $table->foreignId('post_id')->constrained()->cascadeOnDelete();
    $table->foreignId('user_id')->constrained();
    $table->text('body');
    $table->boolean('approved')->default(false);
    $table->timestamps();
});

use Illuminate\Database\Eloquent\Relations\HasMany;
use Illuminate\Database\Eloquent\Relations\BelongsTo;

class Post extends Model
{
    protected $fillable = ['user_id', 'title', 'body', 'status'];

    /** Post HAS MANY comments */
    public function comments(): HasMany
    {
        return $this->hasMany(Comment::class);
    }

    /** Post BELONGS TO a user (author) */
    public function author(): BelongsTo
    {
        return $this->belongsTo(User::class, 'user_id');
    }
}

class Comment extends Model
{
    protected $fillable = ['post_id', 'user_id', 'body', 'approved'];

    /** Comment BELONGS TO one post */
    public function post(): BelongsTo
    {
        return $this->belongsTo(Post::class);
    }
}

// ── READ ─────────────────────────────────────────────────────
$post = Post::find(1);
$comments = $post->comments;          // Collection of Comment models

// Chain conditions using the method (not property)
$approved = $post->comments()
    ->where('approved', true)
    ->latest()
    ->get();

// Count without loading all records
$count = $post->comments()->count();

// Eager load (prevents N+1)
$posts = Post::with('comments')->get();

// Nested eager loading
$posts = Post::with('comments.user')->get();

// ── CREATE ───────────────────────────────────────────────────
$post->comments()->create([
    'user_id' => auth()->id(),
    'body'    => 'Great article!',
]);

// ── whereHas — filter parents by child condition ──────────────
$postsWithApproved = Post::whereHas('comments', function ($q) {
    $q->where('approved', true);
})->get();

// withCount — add comment count to each post
$posts = Post::withCount('comments')->get();
echo $posts[0]->comments_count;

Schema::create('roles', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->string('slug')->unique();
    $table->timestamps();
});

// Pivot: role_user (alphabetical: r before u)
Schema::create('role_user', function (Blueprint $table) {
    $table->foreignId('user_id')->constrained()->cascadeOnDelete();
    $table->foreignId('role_id')->constrained()->cascadeOnDelete();
    $table->primary(['user_id', 'role_id']);   // composite PK
    $table->timestamp('assigned_at')->nullable(); // extra pivot column
});

use Illuminate\Database\Eloquent\Relations\BelongsToMany;

class User extends Model
{
    public function roles(): BelongsToMany
    {
        return $this->belongsToMany(Role::class)
                    ->withPivot('assigned_at')   // expose extra column
                    ->withTimestamps();            // if pivot has timestamps
    }
}

class Role extends Model
{
    public function users(): BelongsToMany
    {
        return $this->belongsToMany(User::class)
                    ->withPivot('assigned_at');
    }
}

$user = User::find(1);

// ── ATTACH — insert into pivot (does NOT remove existing) ─────
$user->roles()->attach(3);
$user->roles()->attach([1, 2, 3]);
$user->roles()->attach(3, ['assigned_at' => now()]); // with extra pivot data

// ── DETACH — remove from pivot ────────────────────────────────
$user->roles()->detach(3);         // detach one
$user->roles()->detach();           // detach ALL roles

// ── SYNC — replaces ALL current records with given set ────────
$user->roles()->sync([1, 2, 3]);    // user now has only roles 1,2,3

// ── syncWithoutDetaching — add without removing existing ──────
$user->roles()->syncWithoutDetaching([4, 5]);

// ── TOGGLE — attach if missing, detach if present ─────────────
$user->roles()->toggle([1, 3]);

// ── READ — access pivot data ──────────────────────────────────
foreach ($user->roles as $role) {
    echo $role->name;
    echo $role->pivot->assigned_at;  // extra pivot column
}

use Illuminate\Database\Eloquent\Relations\HasOneThrough;

class Mechanic extends Model
{
    public function carOwner(): HasOneThrough
    {
        return $this->hasOneThrough(
            Owner::class,     // Final model we want to reach
            Car::class,       // Intermediate model to pass through
            'mechanic_id',    // FK on cars table → mechanics
            'car_id',         // FK on owners table → cars
            'id',             // Local key on mechanics table
            'id'              // Local key on cars table
        );
    }
}

use Illuminate\Database\Eloquent\Relations\HasOne;
use Illuminate\Database\Eloquent\Relations\HasMany;

class User extends Model
{
    /** All orders */
    public function orders(): HasMany
    {
        return $this->hasMany(Order::class);
    }

    /** Only the most recent order */
    public function latestOrder(): HasOne
    {
        return $this->hasOne(Order::class)->latestOfMany();
    }

    /** Only the oldest order */
    public function oldestOrder(): HasOne
    {
        return $this->hasOne(Order::class)->oldestOfMany();
    }

    /** Order with the highest total amount */
    public function largestOrder(): HasOne
    {
        return $this->hasOne(Order::class)->ofMany('total', 'max');
    }

    /** Latest shipped order — conditional ofMany */
    public function latestShippedOrder(): HasOne
    {
        return $this->hasOne(Order::class)->ofMany(
            ['created_at' => 'max'],
            fn($query) => $query->where('status', 'shipped')
        );
    }
}

use Illuminate\Database\Eloquent\Relations\HasManyThrough;

class Country extends Model
{
    public function posts(): HasManyThrough
    {
        return $this->hasManyThrough(
            Post::class,      // Final model — what we want
            User::class,      // Intermediate model — how we get there
            'country_id',     // FK on users table → countries
            'user_id',        // FK on posts table → users
            'id',             // Local key on countries
            'id'              // Local key on users
        );
    }
}

Schema::create('images', function (Blueprint $table) {
    $table->id();
    $table->string('url');

    // morphs() creates TWO columns:
    // imageable_id   → unsignedBigInteger
    // imageable_type → string (stores the model class name)
    $table->morphs('imageable');

    $table->timestamps();
});

use Illuminate\Database\Eloquent\Relations\MorphOne;
use Illuminate\Database\Eloquent\Relations\MorphTo;

class Image extends Model
{
    /** Returns the owning model (User OR Post — resolved dynamically) */
    public function imageable(): MorphTo
    {
        return $this->morphTo();
    }
}

class User extends Model
{
    public function image(): MorphOne
    {
        return $this->morphOne(Image::class, 'imageable');
    }
}

class Post extends Model
{
    public function image(): MorphOne
    {
        return $this->morphOne(Image::class, 'imageable');
    }
}

use Illuminate\Database\Eloquent\Relations\MorphMany;
use Illuminate\Database\Eloquent\Relations\MorphTo;

class Comment extends Model
{
    public function commentable(): MorphTo
    {
        return $this->morphTo();  // resolves to Post or Video dynamically
    }
}

class Post extends Model
{
    public function comments(): MorphMany
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

class Video extends Model
{
    public function comments(): MorphMany
    {
        return $this->morphMany(Comment::class, 'commentable');
    }
}

use Illuminate\Database\Eloquent\Relations\Relation;

public function boot(): void
{
    // Instead of storing "App\Models\Post" in DB, store short alias "post"
    // Makes DB portable if you rename/move model classes
    Relation::morphMap([
        'post'    => Post::class,
        'video'   => Video::class,
        'comment' => Comment::class,
    ]);
}

Schema::create('tags', function (Blueprint $table) {
    $table->id();
    $table->string('name');
    $table->string('slug')->unique();
    $table->timestamps();
});

// Morph pivot table — named taggables (model + 'ables')
Schema::create('taggables', function (Blueprint $table) {
    $table->foreignId('tag_id')->constrained()->cascadeOnDelete();
    $table->morphs('taggable');  // taggable_id + taggable_type
    $table->primary(['tag_id', 'taggable_id', 'taggable_type']);
});

use Illuminate\Database\Eloquent\Relations\MorphToMany;
use Illuminate\Database\Eloquent\Relations\MorphedByMany;

class Tag extends Model
{
    /** All posts that have this tag */
    public function posts(): MorphedByMany
    {
        return $this->morphedByMany(Post::class, 'taggable');
    }

    /** All videos that have this tag */
    public function videos(): MorphedByMany
    {
        return $this->morphedByMany(Video::class, 'taggable');
    }
}

class Post extends Model
{
    public function tags(): MorphToMany
    {
        return $this->morphToMany(Tag::class, 'taggable');
    }
}

class Video extends Model
{
    public function tags(): MorphToMany
    {
        return $this->morphToMany(Tag::class, 'taggable');
    }
}

🧠 Section A — Basics (One to One & One to Many)

1. In a hasOne relationship, which table holds the foreign key — the parent or the child table?
2. What is the difference between $user->profile and $user->profile() in Eloquent?
3. You have Post hasMany Comment. Write the Eloquent call to get all approved comments ordered newest first, without loading all comments.
4. What Laravel problem does eager loading (with()) solve? Show lazy vs eager example.
5. What default foreign key name does Eloquent assume for Post::belongsTo(User::class)?
6. How do you use withCount() to add a comment count to each post without loading all comments?
7. What does cascadeOnDelete() do in a migration and when should you use it?

🧠 Section B — Many to Many & Pivot

1. What naming convention must the pivot table follow for Eloquent to auto-detect it in belongsToMany?
2. Explain the difference between attach(), sync(), syncWithoutDetaching(), and toggle().
3. How do you store and read extra columns (e.g. assigned_at) on a pivot table?
4. Write the full model and migration for a Student that belongs to many Courses, with a pivot column enrolled_at.
5. If you call $user->roles()->sync([1, 2, 3]) and the user previously had roles [2, 4, 5], what is the final state?
6. How do you filter users who have at least one role with slug 'admin' using whereHas?

🧠 Section C — Through Relationships & Has One of Many

1. When would you choose hasManyThrough over manually loading the intermediate model?
2. What is the key advantage of hasOne()->latestOfMany() over hasMany()->latest()->first()?
3. Write the model method to get a User's most expensive Order (highest total value).
4. Explain all 6 parameters of hasManyThrough() in plain English with an example.
5. Can you use with('latestOrder') for eager loading when defined via hasOne()->latestOfMany()? Why or why not?

🧠 Section D — Polymorphic Relationships

1. What two database columns does $table->morphs('commentable') create, and what does each store?
2. What is Relation::morphMap() and why should you always register it in AppServiceProvider::boot()?
3. Explain the difference between morphOne, morphMany, and morphToMany.
4. Write the full Tag model with posts() and videos() inverse relationships using morphedByMany.
5. When should you use a polymorphic relationship instead of creating separate tables for each parent type? Give a real-world scenario.

🧠 Section E — Advanced / Gotchas

1. What happens if you call $post->comments inside a foreach loop over 100 posts without eager loading?
2. What is the difference between whereHas('comments') and with('comments')?
3. Can you chain query builder conditions on a relationship result like $post->comments()->where(...)->get()? Explain why.
4. How do you eager-load a nested relationship like comments with their authors on a list of posts?
5. If you define public function latestOrder(): HasOne using latestOfMany(), what class must the return type hint be — HasOne or HasMany?
6. You have a polymorphic likes table where both Post and Comment can be liked. Write the full migration, Like model, and Post model relationship.