Proposal: Add Support for Aliases in with() for Eager Loading

[TimKunze96]

Currently, Laravel's with() method for eager loading always attaches the loaded relation using the original relation name. This becomes restrictive when:

• You want to load the same relation multiple times under different constraints.
• You want to rename a relation in the output for semantic clarity.
• You need to avoid conflicts with existing attributes or relationships on the model.

There’s no built-in way to assign a custom name to an eager-loaded relation.

Proposed Feature

Allow an alias to be provided directly in the with() array using the syntax:

User::with([
    'skills as satisfied_skills' => fn ($query) => $query->whereIn('id', $requiredSkillIds)
])->get();

This would attach the results of the eager load to the model as:

$user->satisfied_skills;

instead of:

$user->skills;

Benefits

• Keeps eager loading expressive and clean
• Avoids having to redefine or duplicate relations
• Allows for loading a relation multiple times with different filters
• Reduces frontend transformation complexity when using Laravel as an API backend

Notes

The alias would only affect how the relation is attached to the model.
Internally, Laravel could split the key at " as " and treat the left side as the relation name, the right side as the alias.
This pattern is already familiar from SQL and can be implemented without breaking existing behavior.

Backward Compatibility

This would be fully backward-compatible, since:

• The " as " syntax is currently not a valid key format in with()
• Existing relation loading logic would remain unchanged

Summary

Adding support for relation as alias syntax in Laravel's with() method would make eager loading more flexible, more expressive, and better suited for modern applications, especially when building APIs or reusing filtered relationships.

[Sophist-UK]

I like the concept but I don't like the proposed syntax. I would propose as an alternative:

User::with([
    'skills->satisfied_skills' => fn ($query) => $query->whereIn('id', $requiredSkillIds)
])->get();

[shaedrich]

This rather reads like satisfied_skills is a property on an object called skills which could be confusing

[macropay-solutions]

We solved this by declaring the alias as another relation name:

public function relation(): HasOne
{
...
}

public function relationAlias(): HasOne
{
    return $this->relation()->where(...); // or ->scope().
}

Regarding the clashes between relation names and attributes and model properties we also introduced ->a for attributes and ->r for relations.

Your proposal will generate bugs because the alias will not be autocompleted nor will it be expected for other devs that did not introduce the alias because the function is not defined in the model.

[shaedrich]

While this reads nicely, I'd prefer not having to have to split a string, meaning, there should be literals for the relation and the alias rather than only dynamically calculated ones at runtime. However, I'm not sure how this can be done best

New alias() method on Builder

User::with([
    'skills' => fn ($query) => $query->alias('satisfied_skills')->whereIn('id', $requiredSkillIds)
])->get();

✅ literals exist for both relation and alias	❌ alias has to be defined on the right-hand side rather than on the same side as the relation which can be counterintuitive

New #[Alias] attribute

User::with([
    'skills' => #[Alias('satisfied_skills')] fn ($query) => $query->whereIn('id', $requiredSkillIds)
])->get();

✅ literals exist for both relation and alias	❌ reflection comes with a runtime cost
	❌ reflection is probably not Taylor's most preferred solution

[TimKunze96]

Instead of changing how with() works, it could just be a separate function like withAliased() that takes the relation name, an alias, and maybe a builder callback. That makes it clear what’s happening and avoids needing extra stuff like attribute imports.

The only downside is that you wouldd have to call it multiple times if you want to load several aliases.

User::query()
    ->withAliased('skills', 'missing_skills', fn ($query) => 
        $query->whereNotIn('id', [1, 2, 3])
    )
    ->withAliased('skills', 'recommended_skills', fn ($query) => 
        $query->where('recommended', true)
    )
    ->get();

[shaedrich]

While this is probably the safest way, I have my doubts about people actually using when they would have to call it multiple times 🤔

[TimKunze96]

If we really want to keep it to a single method call, something like this could work:

User::query()
    ->withAliased([
        ['skills', 'missing_skills', fn ($q) => $q->whereNotIn('id', [1, 2, 3])],
        ['skills', 'recommended_skills', fn ($q) => $q->where('recommended', true)],
    ])
    ->get();

That said, passing around 3-element arrays like that feels kinda awkward for me and it is probably easy to mess up. I'd prefer a more structured approach

[shaedrich]

This might be the convenience option to get acceptance and usage 👍🏻 If we offer both (one internally calling the other), people can choose themselves what they like more in their project

[DanielCHood]

A potential problem with this is that it leads to dynamic relationships which become hard to document. Right now I define all of my relationships as properties to make things like phpstan happy plus provide context to IDEs. With this, ->recommended_skills will always seem to be undefined.

For that reason I actually prefer the solution mentioned in #56107 (comment)