How to lazy load nested relationship?

[benjivm]

When I need to load a nested relationship with Laravel Resources I can do something like:

// Loading the relationship
new ModelResource(Model::with('foo.bar')->get());

// Relevant ModelResource part
$this->whenLoaded('foo', fn () => $this->when(
        $this->foo->relationLoaded('bar'), 
        fn () => $this->foo->bar->baz
    )
)

I've tried the following with no luck:

Lazy::whenLoaded('foo.bar', $model, fn () => $model->foo->bar->baz)
Lazy::whenLoaded('foo', $model, fn () => Lazy::whenLoaded('bar', $model->foo, fn () => $model->foo->bar->baz))

How can I achieve this?

[rubenvanassche]

Hi @benjivm,

At the moment we do not have support for this kind of checking. This is actually also quire complicated to achieve. In the case of simple relations with a 1:1 mapping there's no problem.

For example if foo.bar is requested, we first check if foo is loaded on our model and then we check if bar is loaded on foo. If that's the case the lazy closure can be executed. But as soon as we add relations with multiple models to the mix we start to get in trouble.

For example let say the foo relation is actually a collection of model, now we need to check if each bar relation is loaded on all the foo models.

In this case I would opt for using a conditional Lazy where you write the condition of relations loaded out manually.

[thewebartisan7]

@rubenvanassche I get this error so I suppose it's because of this limitation right?

Error:

  Attempted to lazy load [posts] on model [Domain\Tags\Models\Tag] but lazy loading is disabled.

    $commentDataWithUser = $commentData->include('user.*', 'post.*')->toArray();

I have Comments belong to Post and Post many to many with Tags.
In my TagData I have:

    public static function fromModel(Tag $tag): self
    {
        return new self(
            // Using Lazy::whenLoaded() doesn't get error
            // posts: Lazy::whenLoaded('posts', $tag, fn () => PostData::collection($tag->posts)),

           // Using Lazy::create() get in error
            posts: Lazy::create(fn () => PostData::collection($tag->posts)),
        );
    }

Or also if I use whenLoaded() in PostData it doesn't get error:

    public static function fromModel(Post $post): self
    {
        return new self(
            // Using Lazy::create() get in error
            // tags: Lazy::create(fn () => TagData::collection($post->tags)),

            // Using Lazy::whenLoaded() doesn't get error
            tags: Lazy::whenLoaded('tags', $post, fn () => TagData::collection($post->tags)),
        );
    }

So it seem that we need always use whenLoaded(), because using include('relation.*') will attempt always to load this nested relation right?

Why not just skip nested relation in this case?