Laravel Inertia Data Providers

https://github.com/webfox/laravel-inertia-dataproviders
Admin
A package that encapsulates logic for Inertia.js views in Laravel, keeping controllers clean and...
Tokens:2,530
Snippets:10
Trust Score:2.2
License:MIT
Update:1 year ago
Show doc for...
Tokens:
Raw
### Install Laravel Inertia Data Providers

Source: https://github.com/webfox/laravel-inertia-dataproviders/blob/main/README.md

Installs the webfox/laravel-inertia-dataproviders package using Composer and optionally publishes the configuration file.

```bash
composer require webfox/laravel-inertia-dataproviders

php artisan vendor:publish --provider="Webfox\InertiaDataProviders\InertiaDataProvidersServiceProvider"
```

--------------------------------

### Simple Laravel Inertia Data Provider

Source: https://github.com/webfox/laravel-inertia-dataproviders/blob/main/README.md

A basic data provider class extending `DataProvider`. Public methods and properties are automatically made available to the Inertia page. This example demonstrates a public string property and a public method returning an integer.

```php
<?php
declare(strict_types=1);

namespace App\Http\DataProviders;

use Inertia\LazyProp;
use App\Services\InjectedDependency;
use Webfox\InertiaDataProviders\DataProvider;

class DemoDataProvider extends DataProvider
{
    public string $someData = 'data';
    
    public function moreData(): int
    {
        return time();
    }
}
```

--------------------------------

### Advanced Laravel Inertia Data Provider with Lazy Loading

Source: https://github.com/webfox/laravel-inertia-dataproviders/blob/main/README.md

An advanced data provider showcasing constructor property promotion for automatic data availability, static data assignment, and methods with different evaluation strategies. It includes examples for methods that are always included, deferred, and lazy-loaded, leveraging Laravel's service container for dependency injection.

```php
<?php
declare(strict_types=1);

namespace App\Http\DataProviders;

use Inertia\DeferProp;
use Inertia\LazyProp;
use App\Services\InjectedDependency;
use Webfox\InertiaDataProviders\DataProvider;
use Closure;

class DemoDataProvider extends DataProvider
{

    public function __construct(
        /*
         * All public properties are automatically available in the page
         * This would be available to the page as `demo`
         */
        public Demo $demo;
    )
    {
        /*
         * Data providers have a `staticData` property, which you can use to add any data that doesn't warrant a full
         * property or separate method
         */
        $this->staticData = [
            /*
             * This will be available to the page as `title`
             */
            'title' => $this->calculateTitle($demo),
        ];
    }
    
    /*
     * All public methods are automatically evaluated as data and provided to the page.
     * ALWAYS included on first visit, OPTIONALLY included on partial reloads, ALWAYS evaluated
     * This would be available to the page as `someData`.
     * Additionally these methods are resolved through Laravel's service container, so any parameters will be automatically resolved.
     */
    public function someData(InjectedDependency $example): array
    {
        return [
            'some' => $example->doThingWith('some'),
            'more' => 'data',
        ];
    }
    
    /*
     * If a method is typed to return a DeferProp, it will only be evaluated in a deferred request after the page has loaded
     * NEVER included on first visit, OPTIONALLY included on partial reloads, ALWAYS evaluated after the page has loaded.
     * Additionally the deferred callback methods are resolved through Laravel's service container, so any parameters will be automatically resolved.
     * @see https://inertiajs.com/deferred-props
     */
    public function deferredExample(): DeferProp
    {
        return Inertia::defer(
            fn () => $this->demo->aHeavyCalculation()
        );
    }
    
    /*
     * If a method is typed to return a LazyProp, it will only be evaluated when requested following inertia's rules for lazy data evaluation
     * NEVER included on first visit, OPTIONALLY included on partial reloads, ONLY evaluated when needed
     * Additionally the lazy callback methods are resolved through Laravel's service container, so any parameters will be automatically resolved.
     * @see https://inertiajs.com/partial-reloads#lazy-data-evaluation
     */
    public function lazyExample(): LazyProp
    {
        return Inertia::lazy(
            fn (InjectedDependency $example) => $example->aHeavyCalculation($this->demo)
        );
    }
    
    /*
     * If a method returns a `Closure` it will be evaluated as a lazy property.
     * ALWAYS included on first visit, OPTIONALLY included on partial reloads, ONLY evaluated when needed
     * Additionally the callback methods are resolved through Laravel's service container, so any parameters will be automatically resolved.
     * @see https://inertiajs.com/partial-reloads#lazy-data-evaluation
     */
    public function quickLazyExample(): Closure
    {
        return function(InjectedDependency $example): string {
            return $example->formatName($this->demo->user->name);
        };
    }
    
    /*
     * `protected` and `private` methods are not available to the page
     */
    protected function calculateTitle(Demo $demo): string
    {
        return $demo->name . ' Demo';
    }

}
```

--------------------------------

### Convert DataProvider to Nested Array

Source: https://github.com/webfox/laravel-inertia-dataproviders/blob/main/README.md

Provides an example of converting a DataProvider's dataset into a nested array format using the `toNestedArray()` method. This is useful for JSON responses or other array-based data handling.

```php
use App\Models\Demo;
use Illuminate\Http\Request;
use App\DataProviders\TabDataProvider;
use App\DataProviders\DemoDataProvider;
use App\DataProviders\CreateVenueDataProvider;

class DemoController extends Controller
{
    public function show(Request $request, Demo $demo)
    {
        return (new DemoDataProvider($demo))->toNestedArray();
    }
}
```

--------------------------------

### Return Multiple DataProviders with collection()

Source: https://github.com/webfox/laravel-inertia-dataproviders/blob/main/README.md

Demonstrates how to return multiple DataProviders by merging them into a collection using `DataProvider::collection`. Later providers in the collection override earlier ones if there are duplicate keys.

```php
use App\Models\Demo;
use App\DataProviders\TabDataProvider;
use App\DataProviders\DemoDataProvider;

class DemoController extends Controller
{
    public function show(Demo $demo)
    {
        return Inertia::render('DemoPage', DataProvider::collection(
            new TabDataProvider(current: 'demo'),
            new DemoDataProvider($demo),
        ));
    }
}
```

--------------------------------

### Generate Inertia Data Provider using Artisan

Source: https://github.com/webfox/laravel-inertia-dataproviders/blob/main/README.md

Generates a new Inertia Data Provider class using the `make:data-provider` Artisan command. It takes the desired name as an argument and can optionally overwrite an existing file.

```bash
php artisan make:data-provider {name}
php artisan make:data-provider UserProfileDataProvider
```

--------------------------------

### Add DataProvider to Collection Dynamically

Source: https://github.com/webfox/laravel-inertia-dataproviders/blob/main/README.md

Illustrates how to add a DataProvider to an existing collection using the `DataProviderCollection::add` method. This allows for dynamic addition of data providers based on certain conditions.

```php
use App\Models\Demo;
use App\DataProviders\TabDataProvider;
use App\DataProviders\DemoDataProvider;
use App\DataProviders\CreateVenueDataProvider;

class DemoController extends Controller
{
    public function show(Demo $demo)
    {
        $pageData = DataProvider::collection(
            new TabDataProvider(current: 'demo'),
            new DemoDataProvider($demo),
        );
        
        if($demo->has_venue) {
            $pageData->add(new CreateVenueDataProvider($demo));
        }

        return Inertia::render('DemoPage', $pageData);
    }
}
```

--------------------------------

### Use Data Provider in Inertia Controller (Mixed Data)

Source: https://github.com/webfox/laravel-inertia-dataproviders/blob/main/README.md

Renders an Inertia page, including a data provider instance as part of a larger data array. This allows combining data from the provider with other static or dynamic data.

```php
use App\Models\Demo;
use App\DataProviders\DemoDataProvider;

class DemoController extends Controller
{
    public function edit(Demo $demo)
    {
        return Inertia::render('DemoPage', [
          'some' => 'data',
          'more' => 'data',
          'demo' => new DemoDataProvider($demo),
        ]);
    }
}
```

--------------------------------

### Conditionally Include DataProviders in a Collection

Source: https://github.com/webfox/laravel-inertia-dataproviders/blob/main/README.md

Shows how to conditionally add DataProviders to a collection based on model attributes. It uses the `when` and `unless` methods to include or exclude providers like `CreateVenueDataProvider` and `EditDemoDataProvider`.

```php
use App\Models\Demo;
use App\DataProviders\TabDataProvider;
use App\DataProviders\DemoDataProvider;
use App\DataProviders\EditDemoDataProvider;
use App\DataProviders\CreateVenueDataProvider;

class DemoController extends Controller
{
    public function show(Demo $demo)
    {
        return Inertia::render('DemoPage', DataProvider::collection(
            new TabDataProvider(current: 'demo'),
            new DemoDataProvider($demo),
        )->when($demo->has_venue, function (DataProviderCollection $collection) use($demo) {
            $collection->push(new CreateVenueDataProvider($demo));
        })
        ->unless($demo->locked, function (DataProviderCollection $collection) use($demo) {
            $collection->push(new EditDemoDataProvider($demo));
        }));
    }
}
```

--------------------------------

### Use Data Provider in Inertia Controller (Directly)

Source: https://github.com/webfox/laravel-inertia-dataproviders/blob/main/README.md

Renders an Inertia page, passing a data provider instance directly as the response data. This is useful when the data provider contains all the necessary data for the view.

```php
use App\Models\Demo;
use App\DataProviders\DemoDataProvider;

class DemoController extends Controller
{
    public function show(Demo $demo)
    {
        return Inertia::render('DemoPage', new DemoDataProvider($demo));
    }
}
```
Tokens:
Raw