Inverse Relations

[cxlblm]

Relation declarations are often reciprocal between two model classes. For example, User is related to Order via the orders relation, and Order is related back to User via the user relation.

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

class Order extends Model
{
    public function user(): BelongsTo
    {
        return $this->belongsTo('users');
    }
}

// SELECT * FROM `users` WHERE `id` = 123
$user1 = Customer::find(123);

// SELECT * FROM `order` WHERE `user_id` = 123
$order = $user->orders[0];

// SELECT * FROM `user` WHERE `id` = 123
$user2 = $order->user;

// displays "not the same"
echo $user2 === $user ? 'same' : 'not the same';

We would think $user and $user2 are the same, but they are not!
Can we support inverseOf syntax like yii?

[rodrigopedra]

You can use the ->is() method

echo $user2->is($user) ? 'same' : 'not the same'; // same

Reference: https://laravel.com/docs/8.x/eloquent#comparing-models

[ambengers]

If you run this on tinker

$user1 = \App\Models\User::find(1);
$user2 = \App\Models\User::find(1);

$user1 === $user2;

The evaluation will always return false, That is why @rodrigopedra suggested to use ->is() when doing model comparisons.

About your N+1 problem - you already know that you will get the same user that you have on the first line, Why query it again within the loop?

$user1 = User::find(123);
$orders = $user->orders;

// other logic
foreach ($orders as $order) {
    $user2 = $order->user;      // N + 1
    
    // If you do $user1->is($user2) they will be the same, so why bother doing $order->user within the loop?
}

[cxlblm]

Thank you for answering my doubts But i don't agree with you! I'm just talking about the simplest example!

[rodrigopedra]

I would rather solve the N+1 problem.

No problem:

$user = User::find(123);
$orders = $user->orders;

// use lazy eager-loading
foreach ($orders->load('user') as $order) {
    $user = $order->user;      // no N+1
}

Docs on lazy eager-loading: https://laravel.com/docs/8.x/eloquent-relationships#lazy-eager-loading

Now, let's assume the "inverse" was set automatically, how would you solve circular dependency when building JSON responses?

Route::get('/test', function () {
    $user = User::find(123);
    $orders = $user->orders;

    // manually setting the "inverse" relation
    foreach($orders as $order) {
        $order->setRelation('user', $user);
    }

    return $orders;
});

Also how would you sync the "inverse" of a belongsToMany() relation? For example: "Users belongs to many Roles", when loading a user's roles would you eager load all the other users for each role when setting the inverse?

With a quick search on the issues and PRs, you would see this discussion was brought up several times throughout the years. They all highlight different pain points, not only serialization.

Here a some comments on such attempts:

This doesn't work properly when the relationship hasn't been loaded yet:

$post = Post::create();
$post->comments()->save(new Comment());
dump($post->comments);

In this case, $post->comments contains the new comment twice. save() also executes an additional query to load the relationship that wouldn't be necessary for many/most of the users.

If the relationship has been loaded, the result is still not ideal because it doesn't respect a potential orderBy() clause the relationship might have.

Reference: #27517 (comment)

To me this is just more complexity in Eloquent to maintain that I'm not sure is super necessary. Especially lazy loading them via some other "inverseRelations" property.

Reference: #20053 (comment)

Pretty sure this has implications for JSON serialization where if you were to serialize a model with a has many... you would also get repeated instances of the parent on each child in the JSON.

Doctrine does something similar to this and it makes consistent JSON generation a total pain in the rear.

Reference: #6720 (comment)

Hope this helps.

[cxlblm]

thank you very much!!!

[rudiedirkx]

Inverse exists now. https://laravel.com/docs/11.x/eloquent-relationships#automatically-hydrating-parent-models-on-children You were way ahead the times @cxlblm

[shaedrich]

#51582 essentially introduced chaperons which should be what you asked for