Polymorphic relationships in Laravel - Mini Project: Build & Apply

Polymorphic Relationships in Laravel

📖 Scenario: You are building a simple blog system where users can comment on both posts and videos. Instead of creating separate comment tables for posts and videos, you will use Laravel's polymorphic relationships to keep comments in one table and link them to either posts or videos.

🎯 Goal: Create a Laravel polymorphic relationship where Comment can belong to either a Post or a Video. You will set up the models, migrations, and relationships step-by-step.

📋 What You'll Learn

Create migrations for posts, videos, and comments tables

Define polymorphic relationship methods in Post, Video, and Comment models

Use Laravel Eloquent conventions for polymorphic relations

Link comments to posts or videos using polymorphic keys

💡 Why This Matters

🌍 Real World

Polymorphic relationships let you reuse one comments table for different content types like posts and videos, saving database space and simplifying code.

💼 Career

Understanding polymorphic relationships is important for Laravel developers building flexible, scalable applications with shared features like comments, tags, or images.

1

Create migrations for posts and videos tables

Create two migrations: one for a posts table with columns id and title, and one for a videos table with columns id and title. Use Laravel's schema builder syntax.

Laravel

// Create migration for posts table
// Create migration for videos table
// Your code here

Hint

Use Schema::create with a closure that defines $table->id() and $table->string('title') for both tables.

2

Create migration for comments table with polymorphic columns

Create a migration for a comments table with columns id, body, commentable_id, and commentable_type. Use Laravel's polymorphic columns naming convention.

Laravel

<?php
// Add migration for comments table with polymorphic columns
// Your code here

Hint

Use $table->unsignedBigInteger('commentable_id') and $table->string('commentable_type') to set up polymorphic keys.

3

Define polymorphic relationship methods in models

In the Post and Video models, add a comments() method that returns $this->morphMany(Comment::class, 'commentable'). In the Comment model, add a commentable() method that returns $this->morphTo().

Laravel

<?php
// Add polymorphic relationship methods to Post, Video, and Comment models
// Your code here

Hint

Use morphMany in Post and Video models, and morphTo in Comment model.

4

Attach comments to posts and videos in a controller example

In a controller method, create a Post and a Video. Then create a Comment for each by using the comments() relationship's create() method with ['body' => 'Your comment text'].

Laravel

<?php
// Create a Post and Video
// Add a comment to each using the comments() relationship
// Your code here

Hint

Use create() on the comments() relationship to add comments linked to the post or video.

Practice

1. What is the main purpose of polymorphic relationships in Laravel?

easy

A. To allow a model to belong to more than one other model on a single association

B. To create many-to-many relationships between two models

C. To enforce strict foreign key constraints in the database

D. To automatically generate database migrations

Solution

1. Step 1: Understand polymorphic relationships

   Polymorphic relationships allow a model to belong to multiple other models using a single association.

2. Step 2: Compare with other relationship types

   Unlike many-to-many or one-to-many, polymorphic lets one model relate to different models without separate foreign keys.

3. Final Answer:

   To allow a model to belong to more than one other model on a single association -> Option A

4. Quick Check:

   Polymorphic relationships = single association to multiple models [OK]

Hint: Polymorphic = one model relates to many different models [OK]

Common Mistakes:

• Confusing polymorphic with many-to-many relationships
• Thinking it automatically creates migrations
• Assuming it enforces database constraints

2. Which method should you use in the related model to define a polymorphic relationship?

easy

A. morphTo()

B. hasMany()

C. belongsToMany()

D. morphMany()

Solution

1. Step 1: Identify the related model method

   The related model uses morphTo() to define the polymorphic inverse relationship.

2. Step 2: Differentiate from owning model methods

   Owning models use morphMany(), but the related model uses morphTo().

3. Final Answer:

   morphTo() -> Option A

4. Quick Check:

   Related model uses morphTo() [OK]

Hint: Related model always uses morphTo() for polymorphic [OK]

Common Mistakes:

• Using morphMany() in the related model
• Confusing belongsToMany() with polymorphic
• Using hasMany() instead of morphTo()

3. Given the following code, what will $comment->commentable->name output?

class Comment extends Model {
  public function commentable() {
    return $this->morphTo();
  }
}

$comment = Comment::find(1);

Assuming the comment belongs to a Post with name = 'Laravel Tips'.

medium

A. Error: Undefined property 'name'

B. 'Laravel Tips'

C. null

D. 'Comment'

Solution

1. Step 1: Understand morphTo() behavior

   The commentable() method returns the related model instance, here a Post.

2. Step 2: Access the related model's property

   Accessing name on the Post model returns 'Laravel Tips'.

3. Final Answer:

   'Laravel Tips' -> Option B

4. Quick Check:

   commentable->name = 'Laravel Tips' [OK]

Hint: morphTo() returns related model instance [OK]

Common Mistakes:

• Expecting null if not eager loaded
• Confusing property with method call
• Assuming error without checking model relation

4. What is wrong with this polymorphic relationship definition?

class Image extends Model {
  public function imageable() {
    return $this->morphMany();
  }
}

medium

A. morphMany() requires parameters but none are given

B. No relationship method is needed in Image model

C. The method name should be morphable()

D. The method should be morphTo(), not morphMany()

Solution

1. Step 1: Identify the model role

   Image is the related model, so it should use morphTo() for polymorphic inverse.

2. Step 2: Check method used

   morphMany() is for owning models, not related models.

3. Final Answer:

   The method should be morphTo(), not morphMany() -> Option D

4. Quick Check:

   Related model uses morphTo() [OK]

Hint: Related model must use morphTo(), not morphMany() [OK]

Common Mistakes:

• Using morphMany() without parameters
• Wrong method name for polymorphic inverse
• Thinking no method is needed

5. You want to create a polymorphic relationship where both Post and Video models can have many Comment models. Which of the following is the correct way to define the relationship in the Post model?

hard

A. public function comments() { return $this->belongsToMany(Comment::class); }

B. public function comments() { return $this->hasMany(Comment::class); }

C. public function comments() { return $this->morphMany(Comment::class, 'commentable'); }

D. public function comments() { return $this->morphTo(Comment::class, 'commentable'); }

Solution

1. Step 1: Identify owning model relationship

   Post owns many comments via polymorphic relation, so use morphMany().

2. Step 2: Use correct parameters

   morphMany() requires the related model class and the polymorphic name 'commentable'.

3. Final Answer:

   public function comments() { return $this->morphMany(Comment::class, 'commentable'); } -> Option C

4. Quick Check:

   Owning model uses morphMany() with polymorphic name [OK]

Hint: Owning model uses morphMany() with polymorphic name [OK]

Common Mistakes:

• Using hasMany() instead of morphMany()
• Using morphTo() in owning model
• Using belongsToMany() for polymorphic