Disable wrapping on nested collection

[zigi05]

How do I disable wrapping on a nested collection in the following situation, when I have global wrapping enabled?

class AuthorData extends Data
{
    public function __construct(
        public string $name,
        #[DataCollectionOf(PostData::class)]
        public DataCollection $posts
    ) {
    }
}

AuthorData::from([
    'name' => 'Ruben Van Assche',
    'posts' => [
        [
            'title' => 'Hello laravel-data',
        ],
        [
            'title' => 'What is a data object',
        ],
    ],
]);

So, from a controller I get json like this, but I don't want to have "data" after "posts":

{
    "data": {
        "name": "Ruben Van Assche",
        "posts": {
            "data": [
                {"title": "Hello laravel-data"},
                {"title": "What is a data object"},
            ]
        }
    }
}

[rubenvanassche]

This is the default since it follows JSON:API spec and Laravel Resource defaults, why not disable wrapping in data and then wrap the whole thing within your controller in an array with data?

[zigi05]

in Laravel, nested resources (relationships) are not wrapped in data by default.

I've implemented a workaround by creating a custom data collection with $this->withoutWrapping() in its constructor.

[LWlook]

@rubenvanassche As zigi05 already mentioned, in Laravel nested resources aren't wrapped by default. Is there a possibility to disable this behavior?

[rubenvanassche]

Mhh indeed, always taught they did with ResourceCollections but apparently not:

it('wraps?', function (){
    class NestedResource extends JsonResource{
        public function toArray($request)
        {
            return ['name' => $this->name];
        }
    }

    class NestedResourceCollection  extends ResourceCollection{
        public $resource = NestedResource::class;
    }

   class SomeResource extends JsonResource{
         public function toArray($request)
         {
              return [
                  'name' => $this->name,
                  'nested' => NestedResource::collection($this->nested),
                  'nested2' => new NestedResourceCollection($this->nested),
              ];
         }
   }

   dd(SomeResource::make((object)[
         'name' => 'John Doe',
         'nested' => [
             (object)['name' => 'Jane Doe'],
             (object)['name' => 'John Doe'],
         ]
    ])->toResponse(request())->getData(true));
});

At the moment I lack the time to implement such a thing but I would certainly accept a PR.

[zigi05]

My workaround I ended up using in v3 is that I created a custom collection and then I use that collection in nested resources that I want to disable the wrapping for.

class DataCollectionWithoutWrapping extends DataCollection
{
    public function __construct(
        string $dataClass,
        Enumerable|array|DataCollection|null $items,
    ) {
        parent::__construct($dataClass, $items);

        $this->withoutWrapping();
    }
}

class PostData extends Data
{
    protected static string $_collectionClass = DataCollectionWithoutWrapping::class;

    public function __construct(
        public int $id,
        public string $title,
    ) {
    }
}

[LWlook]

@zigi05 Thank you, this looks like a neat solution, hopefully this will work on v4 too.

[BobbyBorisov]

guys, is there a way to disable wrapping for nested Collections?

[bcorcoran]

Not a full solution, but I did discover a workaround for now (for v4):

This method is more of a "soft global" wrap.

Disable global wrapping in config/data.php and then create a new "base" Data class, such as the following (you can name it whatever you want):

<?php

namespace App\Data;

use Spatie\LaravelData\Data;

class DataWithoutNestedWrapping extends Data
{
    public function defaultWrap(): string
    {
        return 'data';
    }
}

And use it instead of Data, like so:

class UserData extends DataWithoutNestedWrapping
{
    public function __construct(
         // ...
         #[DataCollectionOf(SometimesNestedData::class)]
        public ?DataCollection $sometimesNested,
    ) {}
}

class SometimesNestedData extends DataWithoutNestedWrapping
{
    public function __construct(
         // ...
    ) {}
}

It does not appear that any of the nested collections get wrapped.

You can also do this with a trait without using this intermediary class but then you have to add an additional line to every class which I felt was a bit too tedious.

[LWlook]

Nice workaround, thank you for sharing this. Works for me!