Exporting

Inertia Table may export the current view of any table to CSV, Excel, or PDF through Laravel Excel. Pick the columns and formats you want, run the export inline for small datasets, or push large exports onto the queue and notify users when the file is ready.

Introduction

Before continuing, make sure the Laravel Excel package is installed:

composer require maatwebsite/excel

Defining Exports

The Table class exposes an exports() method for defining export options. Create an Export instance via the static make() method and return it from exports().

use InertiaUI\Table\Table;

class Users extends Table
{
    public function exports(): array
    {
        return [
            Export::make(),
        ];
    }
}

By default, the export type is Excel and the label is Excel Export. The make() method accepts five arguments to customize the export:

use Maatwebsite\Excel\Excel;

Export::make(
    label: 'CSV Export',
    filename: 'users.csv',
    type: Excel::CSV,
    authorize: true,
    events: []
);

The type must be one of the constants from the Maatwebsite\Excel\Excel class. Some types, like PDF, require additional configuration.

Filtering and Selected Rows

By default, the export includes all rows, even when filters are applied or rows are selected in the frontend. You may change this behavior via the limitToFilteredRows or limitToSelectedRows options on make().

Export::make(
    limitToFilteredRows: true,
    limitToSelectedRows: true,
);

Alternatively, you may call the limitToFilteredRows() or limitToSelectedRows() methods:

Export::make()
    ->limitToFilteredRows()
    ->limitToSelectedRows();

To set this as the default for all tables, call the static defaultLimitToFilteredRows() and defaultLimitToSelectedRows() methods on the Export class, typically in your AppServiceProvider:

use InertiaUI\Table\Export;

Export::defaultLimitToFilteredRows();
Export::defaultLimitToSelectedRows();

Authorization

Authorization works the same way as with Row Actions. The authorize option can be a boolean or a Closure.

Export Events

The events array lets you hook into the underlying Laravel Excel events:

use Maatwebsite\Excel\Events\BeforeExport;

Export::make(events: [
    BeforeExport::class => function (BeforeExport $event) {
        $event->writer->getProperties()->setCreator('John Doe');
    },
]);

See the Laravel Excel documentation for the full list of events.

Customizing Exports

Each column may be customized at export time.

Column Mapping

To change the content of a column when exporting, pass a Closure to the exportAs argument or call the exportAs() method:

TextColumn::make('reference', exportAs: function (string $reference) {
    return "#REF-{$reference}";
});

The closure accepts a second argument, which is the Model instance.

TextColumn::make('name')->exportAs(function (string $name, User $user) {
    return $user->is_active ? $name : "Inactive: {$name}";
});

Column Formatting

You may choose a custom format for each column by passing a Closure or string to the exportFormat argument, or by calling the exportFormat() method:

use PhpOffice\PhpSpreadsheet\Style\NumberFormat;

TextColumn::make('amount', exportFormat: NumberFormat::FORMAT_CURRENCY_USD_SIMPLE);

TextColumn::make('amount')->exportFormat(NumberFormat::FORMAT_CURRENCY_USD_SIMPLE);

Column Styling

You may customize the column styling by passing a Closure or array to the exportStyle argument, or by calling the exportStyle() method:

use PhpOffice\PhpSpreadsheet\Style\Style;

TextColumn::make('name', exportStyle: ['font' => ['bold' => true]]);

TextColumn::make('email')->exportStyle(function (Style $style) {
    $style->getFont()->setBold(true);
});

Exclude Columns

To exclude a column from being exported, pass false to the exportAs argument, or call the dontExport() method.

TextColumn::make('Name', exportAs: false);

TextColumn::make('Name')->dontExport();

Defining a Custom Export

For full control over the export, you may supply your own logic via the using argument or the using() method:

use App\Tables\Users;
use InertiaUI\Table\Export;
use InertiaUI\Table\Http\ExportRequest;
use Illuminate\Contracts\Database\Eloquent\Builder;

Export::make()->using(function (Users $table, Export $export, ExportRequest $request, Builder $query) {
    // return response()->download(...);
});

The limitToFilteredRows and limitToSelectedRows options are already applied to the given Query Builder ($query). You may also pass an invokable class:

Export::make(using: new CustomUserExport);

Custom Export with Redirect Response

The using() callback expects a downloadable response. To redirect the user to a different page instead, call the asDownload() method with false:

Export::make()
    ->asDownload(false)
    ->using(function () {
        return to_route('dashboard');
    });

Alternatively, you may use the redirectBackWithDialog() method to stay on the same page and show a dialog:

Export::make()->redirectBackWithDialog();

// With custom title and message
Export::make()->redirectBackWithDialog(
    title: 'Exporting your data',
    message: 'The export is being processed.'
);

Queued Exports

For large datasets, you may queue the export and notify the user when it is ready by calling the queue() method:

Export::make()->queue(
    filename: 'data-export.xlsx',
    disk: 's3'
);

Instead of downloading the file, the user sees a dialog indicating the export is being processed. You may customize the dialog's title and message via the title and message options:

Export::make()->queue(
    filename: 'data-export.xlsx',
    disk: 's3',
    title: 'Exporting your 2024 data',
    message: 'The export is being processed.'
);

You may also notify the user when the export is ready, for example by sending an email. Interact with the queued job by passing a Closure to the withQueuedJob argument or by calling the withQueuedJob() method:

Export::make()->queue()->withQueuedJob(function ($job) {
    $job->chain([
        new SendExportNotification(auth()->user()),
    ]);
});

Likewise, you may set the queue or delay for the job:

Export::make()->queue(
    withQueuedJob: fn ($job) => $job->onQueue('exports')->delay(now()->addMinutes(5))
);

Default Job Configuration

Instead of passing a disk and queue name to each export, you may use the static defaultQueueName() and defaultQueueDisk() methods on the Export class, typically in your AppServiceProvider:

use InertiaUI\Table\Export;

Export::defaultQueueName('exports');
Export::defaultQueueDisk('s3');

Custom Redirect on Queued Export

To skip the dialog and redirect the user to a different page, pass a URL to the redirect option. It accepts a string, a RedirectResponse, or a Closure. A redirectToRoute helper is also available:

Export::make()
    ->queue()
    ->redirect('/exports')
    ->redirect(to_route('exports.index'))
    ->redirect(fn () => route('exports.index'))
    ->redirectToRoute('exports.index');

Data Attributes

You may add Data Attributes to the Export button via the dataAttributes argument on make() or the dataAttributes() method. Keys do not need to be prefixed with data-.

Export::make()->dataAttributes([
    'contents' => 'all-users',
]);

Targeting Exports With CSS

You may target the Export button by its data attributes. For example, to style an Export with the data-content="all-users" attribute:

a[data-content="all-users"] {
    /* ... */
}

Metadata

You may attach metadata to an Export via the meta argument on make() or the meta() method:

Export::make()->meta([
    'key' => 'value',
]);

The default Table component ignores this metadata and does not pass it to any DOM element. It becomes useful when extending the Table component using slots, or when building a custom Table component.