Spatie Laravel Database Mail Templates

https://github.com/spatie/laravel-database-mail-templates
Admin
A Laravel package that allows rendering mailables using templates stored in the database, supporting...
Tokens:8,671
Snippets:30
Trust Score:10
License:MIT
Update:11 months ago
Show doc for...
Tokens:
Raw
### Install Spatie Laravel Database Mail Templates (Bash)

Source: https://github.com/spatie/laravel-database-mail-templates/blob/main/README.md

Provides the command to install the spatie/laravel-database-mail-templates package using Composer. It also includes the command to publish and run the necessary database migrations for the package.

```bash
composer require spatie/laravel-database-mail-templates

php artisan vendor:publish --provider="Spatie\MailTemplates\MailTemplatesServiceProvider" --tag="migrations"

php artisan migrate
```

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

### Setup Database Migration and Seed Mail Templates (PHP)

Source: https://context7.com/spatie/laravel-database-mail-templates/llms.txt

This snippet covers publishing the package's migration file, creating the 'mail_templates' table, and seeding it with example email templates. It includes the necessary Artisan commands and PHP code for the migration and seeder.

```php
php artisan vendor:publish --provider="Spatie\MailTemplates\MailTemplatesServiceProvider" --tag="migrations"

// Migration creates this table structure:
// database/migrations/2018_10_10_000000_create_mail_templates_table.php

use Illuminate\Support\Facades\Schema;
use Illuminate\Database\Schema\Blueprint;
use Illuminate\Database\Migrations\Migration;

class CreateMailTemplatesTable extends Migration
{
    public function up()
    {
        Schema::create('mail_templates', function (Blueprint $table) {
            $table->increments('id');
            $table->string('mailable');              // Mailable class name
            $table->text('subject')->nullable();      // Email subject with variables
            $table->longText('html_template');        // HTML template body
            $table->longText('text_template')->nullable(); // Plain text version
            $table->timestamps();
        });
    }
}

// Run migration
php artisan migrate

// Seed templates
use Illuminate\Database\Seeder;
use Spatie\MailTemplates\Models\MailTemplate;

class MailTemplatesSeeder extends Seeder
{
    public function run()
    {
        MailTemplate::create([
            'mailable' => \App\Mail\WelcomeMail::class,
            'subject' => 'Welcome to {{ appName }}',
            'html_template' => '<h1>Welcome {{ userName }}!</h1><p>We\'re glad you joined.</p>',
            'text_template' => 'Welcome {{ userName }}! We\'re glad you joined.',
        ]);

        MailTemplate::create([
            'mailable' => \App\Mail\PasswordResetMail::class,
            'subject' => 'Reset your password',
            'html_template' => '<p>Click here to reset: <a href="{{ resetUrl }}">Reset Password</a></p>',
            'text_template' => 'Reset your password: {{ resetUrl }}',
        ]);
    }
}
```

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

### Create and Send Mailable with Database Template (PHP)

Source: https://github.com/spatie/laravel-database-mail-templates/blob/main/README.md

Demonstrates how to define a `TemplateMailable`, specify an HTML layout, create a mail template entry in the database, and then send the email. This example highlights the core functionality of using database-stored templates for sending emails in Laravel.

```php
namespace App\Mail;

use Spatie\MailTemplates\TemplateMailable;
use App\User;

class WelcomeMail extends TemplateMailable
{
    /** @var string */
    public $name;

    public function __construct(User $user)
    {
        $this->name = $user->name;
    }
    
    public function getHtmlLayout(): string
    {
        $pathToLayout = storage_path('mail-layouts/main.html');
    
        return file_get_contents($pathToLayout);
    }
}

MailTemplate::create([
    'mailable' => \App\Mail\WelcomeMail::class,
    'subject' => 'Welcome, {{ name }}',
    'html_template' => '<p>Hello, {{ name }}.</p>',
    'text_template' => 'Hello, {{ name }}.'
]);

Mail::to($user->email)->send(new WelcomeMail($user));
```

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

### Getting Available Template Variables

Source: https://github.com/spatie/laravel-database-mail-templates/blob/main/README.md

This PHP code shows how to retrieve a list of available template variables for a given mailable or a mail template instance. The `getVariables()` method can be called statically on the mailable class or on a `MailTemplate` instance after it's created.

```php
WelcomeMail::getVariables();
// ['name', 'email']

MailTemplate::create(['mailable' => WelcomeMail::class, ... ])->getVariables();
// ['name', 'email']

MailTemplate::create(['mailable' => WelcomeMail::class, ... ])->variables;
// ['name', 'email']
```

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

### Custom MailTemplate Model with Custom Logic

Source: https://github.com/spatie/laravel-database-mail-templates/blob/main/README.md

This example shows how to extend the default `MailTemplate` model to include custom relationships and override methods like `scopeForMailable` and `getHtmlLayout`. It allows for specific template fetching based on relationships and custom HTML layouts per group.

```php
use Spatie\MailTemplates\Models\MailTemplate;

class MeetupMailTemplate extends MailTemplate implements MailTemplateInterface
{
    public function meetupGroup(): BelongsTo
    {
        return $this->belongsTo(MeetupGroup::class);
    }
    
    public function scopeForMailable(Builder $query, Mailable $mailable): Builder
    {
        return $query
            ->where('mailable', get_class($mailable))
            ->where('meetup_group_id', $mailable->getMeetupGroupId());
    }
    
    public function getHtmlLayout(): string
    {
        return $this->meetupGroup->mail_layout;
    }
}
```

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

### Run Tests (Bash)

Source: https://github.com/spatie/laravel-database-mail-templates/blob/main/README.md

Command to execute the test suite for the laravel-database-mail-templates package.

```bash
composer test
```

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

### Create a TemplateMailable

Source: https://github.com/spatie/laravel-database-mail-templates/blob/main/README.md

Shows how to create a custom Mailable class that extends `TemplateMailable` to utilize database-stored templates. Public properties of the Mailable are automatically available in the Mustache templates. Requires the `TemplateMailable` base class from the package.

```php
namespace App\Mail;

use TemplateMailable;

class WelcomeMail extends TemplateMailable
{
    /** @var string */
    public $name;
    
    /** @var string */
    public $email;

    public function __construct(User $user)
    {
        $this->name = $user->name;
        $this->email = $user->email;
    }
}
```

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

### Enable Translations for Mail Templates (PHP)

Source: https://github.com/spatie/laravel-database-mail-templates/blob/main/README.md

Shows how to integrate the package with Laravel's translation features by extending the `MailTemplate` model to use the `HasTranslations` trait from the `laravel-translatable` package. This requires changing the `text` columns in the migration to `json` type.

```php
use \Spatie\MailTemplates\MailTemplate;

class MailTemplate extends MailTemplate
{
    use HasTranslations;
    
    public $translatable = ['subject', 'html_template'];
}
```

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

### Create Basic Template Mailable and Send Email (PHP)

Source: https://context7.com/spatie/laravel-database-mail-templates/llms.txt

Demonstrates extending TemplateMailable, creating a MailTemplate record in the database with subject and body, and sending the email. Public properties of the Mailable are automatically available as template variables.

```php
namespace App\Mail;

use Spatie\MailTemplates\TemplateMailable;
use App\Models\User;

class WelcomeMail extends TemplateMailable
{
    /** @var string */
    public $name;

    /** @var string */
    public $email;

    public function __construct(User $user)
    {
        $this->name = $user->name;
        $this->email = $user->email;
    }
}

// Create a database template
use Spatie\MailTemplates\Models\MailTemplate;

MailTemplate::create([
    'mailable' => \App\Mail\WelcomeMail::class,
    'subject' => 'Welcome, {{ name }}!',
    'html_template' => '<h1>Hello, {{ name }}!</h1><p>Your email is {{ email }}</p>',
    'text_template' => 'Hello, {{ name }}! Your email is {{ email }}',
]);

// Send the email
use Illuminate\Support\Facades\Mail;

$user = User::find(1);
Mail::to($user->email)->send(new WelcomeMail($user));
```

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

### Seed Mail Templates in Database

Source: https://github.com/spatie/laravel-database-mail-templates/blob/main/README.md

Demonstrates how to create a database seeder to populate the `mail_templates` table with default email templates. It shows how to associate templates with specific mailables and define subject and body using Mustache tags. Requires the `MailTemplate` model.

```php
use Illuminate\Database\Seeder;

class MailTemplatesSeeder extends Seeder
{
    public function run()
    {
        MailTemplate::create([
            'mailable' => \App\Mail\WelcomeMail::class,
            'subject' => 'Welcome, {{ name }}',
            'html_template' => '<h1>Hello, {{ name }}!</h1>',
            'text_template' => 'Hello, {{ name }}!',
        ]);
    }
}
```

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

### Add Header and Footer to Mail Template Layout (PHP)

Source: https://github.com/spatie/laravel-database-mail-templates/blob/main/README.md

Demonstrates how to extend the `getHtmlLayout()` method in a `TemplateMailable` class to wrap email content with custom HTML headers and footers. The `{{{ body }}}` placeholder is used to insert the compiled template content. This method can also be adapted to use Blade views or read layouts from external files.

```php
use Spatie\MailTemplates\TemplateMailable;

class WelcomeMail extends TemplateMailable
{
    // ...
    
    public function getHtmlLayout(): string
    {
        /**
         * In your application you might want to fetch the layout from an external file or Blade view.
         * 
         * External file: `return file_get_contents(storage_path('mail-layouts/main.html'));`
         * 
         * Blade view: `return view('mailLayouts.main', $data)->render();`
         */
        
        return '<header>Site name!</header>{{{ body }}}<footer>Copyright 2018</footer>';
    }
}

MailTemplate::create([
    'mailable' => WelcomeMail::class,
    'html_template' => '<p>Welcome, {{ name }}!</p>', 
]);

Mail::to($user->email)->send(new WelcomeMail($user));
```

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

### Create Custom Mail Template Model for Multi-Tenant Events

Source: https://context7.com/spatie/laravel-database-mail-templates/llms.txt

Extends the base MailTemplate model to support multi-tenant scenarios by adding a relationship to an 'Event' model and overriding query scopes to filter templates based on the associated event. This allows for event-specific email templates.

```php
namespace App\Models;

use Spatie\MailTemplates\Models\MailTemplate;
use Spatie\MailTemplates\Interfaces\MailTemplateInterface;
use Illuminate\Database\Eloquent\Builder;
use Illuminate\Database\Eloquent\Relations\BelongsTo;
use Illuminate\Contracts\Mail\Mailable;

class EventMailTemplate extends MailTemplate implements MailTemplateInterface
{
    protected $table = 'event_mail_templates';

    public function event(): BelongsTo
    {
        return $this->belongsTo(Event::class);
    }

    // Override query scope to filter by event
    public function scopeForMailable(Builder $query, Mailable $mailable): Builder
    {
        return $query
            ->where('mailable', get_class($mailable))
            ->where('event_id', $mailable->getEventId());
    }

    // Use event-specific layout
    public function getHtmlLayout(): string
    {
        return $this->event->email_layout_html;
    }
}

namespace App\Mail;

use Spatie\MailTemplates\TemplateMailable;
use App\Models\EventMailTemplate;
use App\Models\Event;

class EventNotificationMail extends TemplateMailable
{
    protected static $templateModelClass = EventMailTemplate::class;

    public $eventName;
    public $eventDate;

    protected $event;

    public function __construct(Event $event)
    {
        $this->event = $event;
        $this->eventName = $event->name;
        $this->eventDate = $event->date->format('M d, Y');
    }

    public function getEventId(): int
    {
        return $this->event->id;
    }
}

// Migration: php artisan make:migration create_event_mail_templates_table
// Add: $table->foreignId('event_id')->constrained();

// Create templates per event
$event1 = Event::find(1);
EventMailTemplate::create([
    'event_id' => $event1->id,
    'mailable' => \App\Mail\EventNotificationMail::class,
    'subject' => 'Join us at {{ eventName }}',
    'html_template' => '<p>{{ eventName }} on {{ eventDate }}</p>',
]);

$event2 = Event::find(2);
EventMailTemplate::create([
    'event_id' => $event2->id,
    'mailable' => \App\Mail\EventNotificationMail::class,
    'subject' => 'Don\'t miss {{ eventName }}',
    'html_template' => '<p>Special event: {{ eventName }} - {{ eventDate }}</p>',
]);

// Automatically uses correct template based on event
Mail::to('attendee@example.com')->send(new EventNotificationMail($event1));
Mail::to('attendee@example.com')->send(new EventNotificationMail($event2));

```

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

### Custom Mailable with Valid HTML Layout

Source: https://context7.com/spatie/laravel-database-mail-templates/llms.txt

Defines a custom mailable class that extends `TemplateMailable`. This snippet demonstrates how to correctly implement the `getHtmlLayout` method, ensuring it includes the `{{{ body }}}` placeholder for proper template rendering. Invalid layouts are commented out.

```php
namespace App\Mail;

use Spatie\MailTemplates\TemplateMailable;

class SafeMail extends TemplateMailable
{
    public function getHtmlLayout(): string
    {
        // ❌ Invalid - missing body placeholder
        // return '<header>Header</header><footer>Footer</footer>';

        // ✅ Valid layouts
        return '<header>Header</header>{{{ body }}}<footer>Footer</footer>';
        // or: '{{ body }}'
        // or: '{!! $body !!}' for Blade views
        // or: '@{{{ body }}}' for Blade views
    }
}
```

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

### Exception Handling for Mail Templates

Source: https://context7.com/spatie/laravel-database-mail-templates/llms.txt

Handles errors such as missing email templates or invalid layout configurations using built-in exception types. It allows for logging errors, falling back to default templates, or fixing layout issues.

```php
use Spatie\MailTemplates\Exceptions\MissingMailTemplate;
use Spatie\MailTemplates\Exceptions\CannotRenderTemplateMailable;
use Illuminate\Support\Facades\Mail;
use Illuminate\Support\Facades\Log;

try {
    Mail::to('user@example.com')->send(new WelcomeMail($user));
} catch (MissingMailTemplate $e) {
    // No template exists in database for this mailable
    Log::error("Mail template missing: " . $e->getMessage());
    // Could fall back to default template or notify admin

    // Create a default template
    MailTemplate::create([
        'mailable' => WelcomeMail::class,
        'subject' => 'Welcome',
        'html_template' => '<p>Default welcome message</p>',
    ]);
} catch (CannotRenderTemplateMailable $e) {
    // Layout doesn't contain {{{ body }}} placeholder
    Log::error("Invalid mail layout: " . $e->getMessage());
    // Fix layout or disable layout for this mailable
}
```

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

### Add Layout to Mail Template Model (PHP)

Source: https://github.com/spatie/laravel-database-mail-templates/blob/main/README.md

Illustrates how to define a custom `MailTemplate` model that dynamically fetches its HTML layout from a database column, in this case, a `mail_layout_html` column on a related `Event` model. This approach allows for different layouts based on specific template models or data.

```php
use Spatie\MailTemplates\Models\MailTemplate;

class EventMailTemplate extends MailTemplate
{
    public function event(): BelongsTo
    {
        return $this->belongsTo(Event::class);
    }

    public function getHtmlLayout(): string
    {
        return $this->event->mail_layout_html;
    }
}
```

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

### Implement Custom Mail Template Interface (PHP)

Source: https://context7.com/spatie/laravel-database-mail-templates/llms.txt

This snippet demonstrates how to implement the MailTemplateInterface for custom email template storage and retrieval, such as fetching templates from an external API. It includes a custom model and a Mailable class that uses this custom template model.

```php
namespace App\Models;

use Spatie\MailTemplates\Interfaces\MailTemplateInterface;
use Illuminate\Contracts\Mail\Mailable;

class ApiMailTemplate implements MailTemplateInterface
{
    protected $data;

    public static function findForMailable(Mailable $mailable): self
    {
        // Fetch template from external API
        $mailableClass = get_class($mailable);
        $response = Http::get("https://template-api.example.com/templates", [
            'mailable' => $mailableClass,
        ]);

        if ($response->failed()) {
            throw new \Exception("Template not found for {$mailableClass}");
        }

        $instance = new static();
        $instance->data = $response->json();
        return $instance;
    }

    public function getSubject(): string
    {
        return $this->data['subject'];
    }

    public function getHtmlTemplate(): string
    {
        return $this->data['html'];
    }

    public function getTextTemplate(): ?string
    {
        return $this->data['text'] ?? null;
    }

    public function getHtmlLayout(): ?string
    {
        return $this->data['layout'] ?? null;
    }
}

namespace App\Mail;

use Spatie\MailTemplates\TemplateMailable;
use App\Models\ApiMailTemplate;

class ApiBasedMail extends TemplateMailable
{
    protected static $templateModelClass = ApiMailTemplate::class;

    public $userName;

    public function __construct($userName)
    {
        $this->userName = $userName;
    }
}

// Send email using API-sourced templates
Mail::to('user@example.com')->send(new ApiBasedMail('John'));
```

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

### Add HTML Layout with Header and Footer to Email (PHP)

Source: https://context7.com/spatie/laravel-database-mail-templates/llms.txt

Illustrates overriding the getHtmlLayout() and getTextLayout() methods in a TemplateMailable to wrap the email body with custom HTML or text structures, including headers and footers. This allows for consistent branding across emails.

```php
namespace App\Mail;

use Spatie\MailTemplates\TemplateMailable;

class BrandedMail extends TemplateMailable
{
    public $userName;

    public function __construct($userName)
    {
        $this->userName = $userName;
    }

    public function getHtmlLayout(): string
    {
        // From external file
        return file_get_contents(storage_path('mail-layouts/branded.html'));

        // Or from Blade view
        // return view('emails.layouts.branded')->render();

        // Or inline
        // return '<header><img src="logo.png">My App</header>{{{ body }}}<footer>© 2025 My Company</footer>';
    }

    public function getTextLayout(): string
    {
        return "MY APP\n----------\n{{{ body }}}\n----------\n© 2025 My Company";
    }
}

// storage/mail-layouts/branded.html:
// <html>
//   <head><style>body { font-family: Arial; }</style></head>
//   <body>
//     <header style="background: #333; color: white; padding: 20px;">
//       <h1>My Application</h1>
//     </header>
//     <div style="padding: 20px;">
//       {{{ body }}}
//     </div>
//     <footer style="background: #f0f0f0; padding: 20px; text-align: center;">
//       <p>© 2025 My Company. All rights reserved.</p>
//     </footer>
//   </body>
// </html>

MailTemplate::create([
    'mailable' => \App\Mail\BrandedMail::class,
    'subject' => 'Welcome {{ userName }}',
    'html_template' => '<h2>Hello {{ userName }}</h2><p>Thanks for joining!</p>',
]);

Mail::to('user@example.com')->send(new BrandedMail('John'));
// Result: Full HTML with header, template body, and footer
```

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

### Retrieve Available Template Variables from Mailable Classes

Source: https://context7.com/spatie/laravel-database-mail-templates/llms.txt

Demonstrates how to access public properties of a `TemplateMailable` class to dynamically retrieve a list of available variables that can be used within email templates. This is useful for building template editors.

```php
namespace App\Mail;

use Spatie\MailTemplates\TemplateMailable;

class OrderConfirmationMail extends TemplateMailable
{
    public $orderNumber;
    public $customerName;
    public $totalAmount;
    public $itemCount;

    public function __construct($order)
    {
        $this->orderNumber = $order->number;
        $this->customerName = $order->customer->name;
        $this->totalAmount = $order->total;
        $this->itemCount = $order->items->count();
    }
}

// Get variables from mailable class
$variables = OrderConfirmationMail::getVariables();
// Returns: ['orderNumber', 'customerName', 'totalAmount', 'itemCount']

// Get variables from template model
$template = MailTemplate::create([
    'mailable' => \App\Mail\OrderConfirmationMail::class,
    'subject' => 'Order #{{ orderNumber }} Confirmed',
    'html_template' => '<p>Hi {{ customerName }}, your {{ itemCount }} items totaling ${{ totalAmount }} are confirmed.</p>',
]);

$variables = $template->getVariables();
// Returns: ['orderNumber', 'customerName', 'totalAmount', 'itemCount']

// Also available as attribute
$variables = $template->variables;
// Returns: ['orderNumber', 'customerName', 'totalAmount', 'itemCount']

// Build UI for template editor
echo '<div class="template-editor">';
echo '<h3>Available Variables</h3>';
echo '<ul>';
foreach ($template->variables as $variable) {
    echo "<li><code>{{ {$variable} }}</code></li>";
}
echo '</ul>';
echo '<textarea name="html_template">' . $template->html_template . '</textarea>';
echo '</div>';

```

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

### Custom Mailable Using a Custom MailTemplate Model

Source: https://github.com/spatie/laravel-database-mail-templates/blob/main/README.md

This PHP code demonstrates how to define a custom mailable that utilizes a custom `MailTemplate` model. It sets the `static $templateModelClass` property to point to the custom model and provides necessary methods, like `getMeetupGroupId`, to support the custom template logic.

```php
use Spatie\MailTemplates\TemplateMailable;

class NewMeetupPlannedMail extends TemplateMailable
{
    // use our custom mail template model
    protected static $templateModelClass = MeetupMailTemplate::class;

    /** @var string */
    public $location;
    
    /** @var \App\Models\Meetup */
    protected $meetup; // protected property, we don't want this in the template data

    public function __construct(Meetup $meetup)
    {
        $this->meetup = $meetup;
        $this->location = $meetup->location;
    }
    
    // provide a method to get the meetup group id so we can use it in MeetupMailTemplate
    public function getMeetupGroupId(): int
    {
        return $this->meetup->meetup_group_id;
    }
  
}
```

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

### Multilingual Email Templates with Laravel Translatable

Source: https://context7.com/spatie/laravel-database-mail-templates/llms.txt

Integrate with Laravel's translatable packages to support multiple languages in email templates. This involves modifying database migrations to use JSON columns for translatable fields and extending the MailTemplate model with the HasTranslations trait. It allows creating and sending localized email content.

```php
// composer require spatie/laravel-translatable

// Modify migration to use JSON columns
Schema::create('mail_templates', function (Blueprint $table) {
    $table->increments('id');
    $table->string('mailable');
    $table->json('subject')->nullable();      // JSON for translations
    $table->json('html_template');            // JSON for translations
    $table->json('text_template')->nullable(); // JSON for translations
    $table->timestamps();
});

namespace App\Models;

use Spatie\MailTemplates\Models\MailTemplate as BaseMailTemplate;
use Spatie\Translatable\HasTranslations;

class MailTemplate extends BaseMailTemplate
{
    use HasTranslations;

    public $translatable = ['subject', 'html_template', 'text_template'];
}

// Create multilingual templates
MailTemplate::create([
    'mailable' => \App\Mail\WelcomeMail::class,
    'subject' => [
        'en' => 'Welcome {{ name }}',
        'es' => 'Bienvenido {{ name }}',
        'fr' => 'Bienvenue {{ name }}',
    ],
    'html_template' => [
        'en' => '<h1>Welcome {{ name }}</h1><p>Thanks for joining!</p>',
        'es' => '<h1>Bienvenido {{ name }}</h1><p>¡Gracias por unirte!</p>',
        'fr' => '<h1>Bienvenue {{ name }}</h1><p>Merci de nous rejoindre!</p>',
    ],
]);

// Send localized email
use Illuminate\Support\Facades\Mail;

$user = User::find(1);
Mail::to($user->email)
    ->locale($user->preferred_language)
    ->send(new WelcomeMail($user));
```

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

### Set Additional Data in TemplateMailable

Source: https://github.com/spatie/laravel-database-mail-templates/blob/main/README.md

Illustrates how to pass additional data to the email template that is not directly a public property of the `TemplateMailable` class. This is achieved using the `setAdditionalData()` method, which accepts an associative array. Useful for dynamic data injection.

```php
namespace App\Mail;

use TemplateMailable;

class WelcomeMail extends TemplateMailable
{

    public function __construct(User $user)
    {
        $this->setAdditionalData([
            'name' => 'Joe Bloggs'
        ]);
    }
}
```

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

### Set Additional Template Data in Mailable (PHP)

Source: https://context7.com/spatie/laravel-database-mail-templates/llms.txt

Shows how to use the setAdditionalData() method to inject variables into email templates that are not directly public properties of the Mailable class. This is useful for dynamic data from services or complex logic.

```php
namespace App\Mail;

use Spatie\MailTemplates\TemplateMailable;
use App\Models\User;
use App\Services\RecommendationService;

class PersonalizedMail extends TemplateMailable
{
    public function __construct(User $user, RecommendationService $service)
    {
        $recommendations = $service->getRecommendationsFor($user);

        $this->setAdditionalData([
            'userName' => $user->name,
            'topRecommendation' => $recommendations->first()->name,
            'totalRecommendations' => $recommendations->count(),
            'accountAge' => $user->created_at->diffForHumans(),
        ]);
    }
}

// Template can use these variables
MailTemplate::create([
    'mailable' => \App\Mail\PersonalizedMail::class,
    'subject' => 'Hi {{ userName }}, check out {{ topRecommendation }}',
    'html_template' => '<p>We found {{ totalRecommendations }} items for you. Member since {{ accountAge }}.</p>',
]);
```
Tokens:
Raw