Flexible Presenter

Flexible Presenter is a Laravel package that makes it a breeze to define just the right data to send to your views when using InertiaJS.

When working with Inertia, you ideally don’t want to send more data than necessary to your views. Doing so will slow down your responses and will generally expose data to the front end that’s not required in a given context.

When preparing an Inertia response you’d likely take a couple of approaches. In simple scenarios you could ‘compose’ the data to send to your view directly in the controller:

public function show(Event $event)
{
    return Inertia::render(‘Event/Show’, [
        ‘event’ => $event->only(
            ‘id’,
            ‘title’,
            ‘start_date’,
            ‘description’
        ),
    ]);
}

This works, but your controllers will get bloated and messy rather quickly especially when dealing with multiple models or collections.

You might then decide to encapsulate some of this logic in a Laravel API Resource class.

public function show(Event $event)
{
    return Inertia::render(‘Event/Show’, [
        ‘event’ => new EventResource($event)
    ]);
}

Whilst this is more compact it means that you’ll end up sending all the fields defined in that API resource class whether you actually need it in the view or not. This problem is compounded when dealing with a collection of models. The only solutions are a bit messy (either adding lots of gnarly conditionals to your resource class or creating lots of hyper-specific resource classes).

The Flexible Presenter package sidesteps these issues, allowing you to define presenter classes that take the logic involved in getting data ready for your view layer out of your controller.

It also provides an expressive, fluent API that allows you to modify and reuse your presenters on the fly so that you’re only ever providing relevant data. Let’s look at a quick example.

class EventPresenter extends FlexiblePresenter
{
    public function values()
    {
        return [
            ‘id’ => $this->id,
            ‘title’ => $this->title,
            ‘summary’ => $this->summary,
            ’start_date’ => $this->start_date->toDateString(),
        ];
    }
}

If you’re used to working with API resource classes this should look pretty familiar. With this Presenter class now defined, we can use it in our controllers.

Let’s say we want to show a view that has a full description of an event and a sidebar with a list of event titles and IDs. In this scenario, we can reuse our presenter class, defining just the fields we need on-the-fly:

public function show(Event $event)
{
    $events = Event::all();
 
    return Inertia::render(‘Event/Show’, [
        // this will return all our defined fields
        ‘event’ => EventPresenter::make($event)
        // this will return just the specified
        // fields for each event
        ‘events’ => EventPresenter::collection($events)
            ->only(‘id’, ‘title’)
    ]);
}

There are a number of fluent API methods you can call on a Presenter class instance to define the data you want to send back. You are also able to nest presenters, define lazily-evaluated values, create presenter presets and pass ad hoc fields to presenters as required.

Check out the package documentation for a full breakdown of the options available. Happy presenting!