DataCollection ignores included parameters

[andumy]

Hello,
I've observed that if a Data class Foo contains a DataCollection of another Data, Bar, and Bar has a set of lazy loaded parameters that are not default included, when Foo is converted to json, the Bar entries from the DataCollection contains only the non-lazy properties and the default included properties, regardless of how the DataCollection was created

My use case

class Foo extends Data
{
    public function __construct(
        #[DataCollectionOf(Bar::class)]
        public DataCollection $bars
    ) {}
}

class Bar extends Data
{
    public function __construct(
        public int $id,
        public Lazy|string $title,
        public Lazy|string $description
    ) {}

    public function fromModel(BarModel $model){
        return new self(
            $model->id,
            Lazy::create(fn() => $model->title)->defaultIncluded(),
            Lazy::create(fn() => $model->description),
        );
    }
}

...
return new JsonResponse(
    new Foo(
         Bar::collection(BarModel::all())->include('description')
    )
);

The returned json looks like

{
   bars:[
       {
            id:1,
            title: "title1"
           // I would've expected to see description as well since it was included via ->include('description') 
       },
       ...
   ]
}

From my debugging, the issue seems to occure when the DataCollection is transformed into json inside the Foo. If I were to return directly Bar::collection(BarModel::all())->include('description') inside the JsonResponse, the json indeed contains description. This means that the DataCollection generated via Bar::collection is seting description as included into the PartialTree.

One obvious solution would be to use array instead of DataCollection inside Foo, and create Foo as

new Foo(
         Bar::collection(BarModel::all())->include('description')->toArray()
)

but this would lose the typing so it's not really a solution.

Is this by design or it's a bug? Is there a way to achieve what I'm trying and keep the typing as well?

Thanks!

[andumy]

Ok, so after a lot of digging through the package code, it seems that the proper solution is the following:

return new JsonResponse(
    (new Foo(
         Bar::collection(BarModel::all())
    ))->include('bars.description')
);

Explanation

It seems that when a Data is transformed (toArray, toJson, jsonSerialized, etc), the DataCollection properties are "flattened". This means that instead of treating the partial tree of each individual DataCollection (Bar) from the transformed Data (Foo), only the partial tree of the big Data (Foo) will be treated. The contained DataCollection of the Data will be flattened as sub-properties.

In my example, because I was including properties into Bar, I was modifying the Bar partial trees. But when I was converting Foo into json, the transform was applied to Foo and thus only its partial trees were taken into consideration, where no include was called.

The solution is to call the include on the Data that is transformed, referencing the sub-properties via the object chain.

Note
I couldn't find this anywhere in the documentation this info so it might be worth mentioning it somewhere since I expect it to be a relatively common case and the solution is not necessarily intuitive.

[rubenvanassche]

This is the example we use in the docs: https://spatie.be/docs/laravel-data/v3/as-a-resource/lazy-properties

A collection of SongData in an AlbumData data object.