How do you handle polymorphic relationships in Laravel

Types of Polymorphic Relationships

1. One-to-One Polymorphic
This is where one model can belong to more than one type of model but only one association at a time. For example, an `Image` model could be associated either as a featured image for a `Post` or as an avatar for a `User`.
You define this using the `morphOne` method on the owning models and `morphTo` on the related model.

2. One-to-Many Polymorphic
This is when one model can have many related models of different types. For example, a `Comment` model can belong to either a `Post` or a `Video`.
You use `morphMany` on the parent models and `morphTo` on the child model.

3. Many-to-Many Polymorphic
This is a more complex scenario where many models can be related to many other models polymorphically. For example, both `Post` and `Video` models can share many `Tag` models, and each `Tag` can belong to many `Post` or `Video` models.
You use `morphToMany` on the models that own the tags and `morphedByMany` on the `Tag` model.

How to Set Up Polymorphic Relationships

Database Schema

For polymorphic relationships, the related table contains two columns:

- A foreign key column (e.g., `commentable_id`) that stores the ID of the related model.
- A type column (e.g., `commentable_type`) that stores the class name or alias of the related model.

Laravel provides a convenient migration method `$table->morphs('commentable');` which creates both columns.

For many-to-many polymorphic relationships, an intermediate pivot table is used with columns like `tag_id`, `taggable_id`, and `taggable_type`.

Model Definitions

- On the model that receives the polymorphic relation (e.g., `Comment`), define a method using `morphTo()`:

php
public function commentable()
{
    return $this->morphTo();
}

- On the models that own the polymorphic relation (e.g., `Post`, `Video`), define methods using `morphMany()` or `morphOne()` depending on the relationship:

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

or for one-to-one:

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

- For many-to-many polymorphic relationships, use `morphToMany()` on the owning models:

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

and `morphedByMany()` on the related model:

php
public function posts()
{
    return $this->morphedByMany(Post::class, 'taggable');
}

Custom Morph Types

By default, Laravel stores the fully qualified class name in the type column. You can customize this using Laravel's Morph Map to use aliases instead, which helps if you rename models or want simpler type values:

php
use Illuminate\Database\Eloquent\Relations\Relation;

Relation::enforceMorphMap([
    'post' => 'App\Models\Post',
    'video' => 'App\Models\Video',
]);

This is typically placed in the `boot` method of a service provider.

Use Cases

- Attaching comments, images, or files to multiple models without creating separate tables for each association.
- Tagging system where tags are shared among different models like posts and videos.
- Managing multiple user types or categorizing different entities with a single polymorphic relation.

Summary

Handling polymorphic relationships in Laravel involves:

- Creating polymorphic columns (`*_id` and `*_type`) in the related table.
- Defining `morphTo` on the child model.
- Defining `morphOne`, `morphMany`, or `morphToMany` on the parent models, depending on the relationship type.
- Optionally using Morph Maps for custom type aliases.

This approach allows a single model to be flexibly associated with multiple different models through a single relationship, simplifying database schemas and Eloquent model code[1][2][3][4].

Citations:
[1] https://laravel.com/docs/11.x/eloquent-relationships
[2] https://blog.logrocket.com/polymorphic-relationships-laravel/
[3] https://www.linkedin.com/pulse/laravel-polymorphic-relationship-explained-steps-md-enamul-haque-5y1gc
[4] https://www.sitepoint.com/eloquents-polymorphic-relationships-explained/
[5] https://laravel.io/forum/polymorphic-relationships-and-resources
[6] https://stackoverflow.com/questions/69588698/laravel-polymorphic-relationships-issue
[7] https://laraveldaily.com/post/polymorphic-relations-laravel-open-source-examples
[8] https://laracasts.com/discuss/channels/eloquent/polymorphic-relationship-in-laravel-without-putting-table-name-in-column