Loading hasMany relationship eagerly loads inverse belongsTo unexpectedly

[nunntom]

Tempest version

2.14

PHP version

8.4

Operating system

Linux

Description

When loading a model with a HasMany relationship where the related model defines a BelongsTo relation back to the initial model, the inverse BelongsTo relation model is eagerly loaded, even if not explicitly loaded. Adding #[Lazy] has no effect on this.

This does not cause an issue in itself, but it is not possible to return the resulting model as a JSON response due to infinite recursion.

Steps to reproduce

final class Chicken
{
    use IsDatabaseModel;

    public string $name;

    #[HasMany]
    /** @var \Models\Egg[] */
    public array $eggs;
}

final class Egg
{
    use IsDatabaseModel;

    public int $size;

    #[BelongsTo]
    public Chicken $chicken;
}

$chicken = Chicken::create(
    name: 'Acorn',
);

$egg = Egg::create(
    size: 10,
    chicken: $chicken,
);

$acorn = Chicken::findById($chicken->id)->load('eggs');

$json = json_encode($acorn); // false (JSON_ERROR_RECURSION)

Expectation

I would expect the inverse BelongsTo relation only to be loaded if tagged with #[Eager] or explicitly loaded with load.

[nunntom]

This method seems to be causing this.

tempest-framework/packages/mapper/src/Mappers/ArrayToObjectMapper.php

Line 141 in e957640

private function setChildParentRelation(object $parent, mixed $child, ClassReflector $childClass): void

I have also noticed that this populates the parent model if it is of the same class, regardless of whether it is actually the correct model (same/different key).

Take this example:

final class Person
{
    use IsDatabaseModel;

    public string $name;

    #[HasMany(ownerJoin: 'people.id', relationJoin: 'friend_requests.sender_id')]
    /** @var \Models\FriendRequest[] */
    public array $friendRequestsSent;

    #[HasMany(ownerJoin: 'people.id', relationJoin: 'friend_requests.recipient_id')]
    /** @var \Models\FriendRequest[] */
    public array $friendRequestsReceived;
}

final class FriendRequest
{
    use IsDatabaseModel;

    public string $message;
    public DateTime $sent_at;
    public ?DateTime $accepted_at = null;

    #[BelongsTo(ownerJoin: 'friend_requests.sender_id', relationJoin: 'people.id')]
    public Person $sender;

    #[BelongsTo(ownerJoin: 'friend_requests.recipient_id', relationJoin: 'people.id')]
    public Person $recipient;
}

$person1 = Person::create(
    name: 'Jane Doe',
);

$person2 = Person::create(
    name: 'John Doe',
);

$friend_request = FriendRequest::create(
    message: 'Hi, let\'s be friends!',
    sender: $person1,
    recipient: $person2,
    sent_at: new \DateTimeImmutable(),
);

$person = Person::findById($person1->id)->load('friendRequestsSent');

You'll find that Jane sent a friend request to herself instead of John.

[xHeaven]

These are pretty tough 👀

I think we should stop ArrayToObjectMapper::setParentRelations() during database hydration because it blindly wires same-type parents and creates circular graphs. Inverse relations should be loaded only when the relation is explicitly loaded (or marked with Eager or Lazy attributes).
However, eager loading multiple BelongsTo to the same table would require us to implement proper join aliasing as well. Otherwise, if you set both sender and recipient to Eager, it will throw an ambiguous column error.

Is anyone up for an attempt to fix this?