Configuring the environment variables with valid SMTP credentials enables quick email sending capabilities in your project. However, I encountered a challenge in my scenario where I had to dynamically switch these credentials based on the logged-in user. The existing solution proved inadequate because the framework configures the Mail facade once with the provided environment variables. Consequently, every call to Mail::send() utilizes these initial credentials, as the framework sets up the Mail facade configuration in the MailServiceProvider class, specifically within the registerIlluminateMailer() method. This method configures a singleton instance of the Mailer class, which is then employed each time the Mail facade is used.

Despite this limitation, Laravel’s Mail facade offers a delightful experience with its simple and intuitive API for configuring recipients and email content. To maintain this expressiveness while incorporating dynamically configured credentials, I delved into understanding how the Mailer instance was set up by the framework and explored ways to obtain an instance with alternative SMTP credentials.

Upon further investigation of the Mailer class, I discovered that a new instance could be constructed with a Swift_Mailer object. Notably, the Swift_Mailer class is built with a Swift_SmtpTransport object, housing the SMTP credentials essential for email transmission. Both Swift_Mailer and Swift_SmtpTransport belong to the SwiftMailer package utilized by Laravel for email sending operations.

Armed with this understanding of the dependency chain, I sought a method to construct these objects, allowing me to specify the desired email credentials. The initial step involved creating a new Swift_SmtpTransport object configured with the necessary credentials.

$transport = new Swift_SmtpTransport('SMTP-HOST-HERE', SMTP-PORT-HERE);

$transport->setUsername('SMTP-USERNAME-HERE');

$transport->setPassword('SMTP-PASSWORD-HERE');

// extra configurations here if needed

Afterward, we use the Swift_SmtpTransport to construct our Swift_Mailer instance.

 

 

$swift_mailer = new Swift_Mailer($transport)

 

Now that we have set up these two things, we just need to create a Mailer object with our updated settings. In the MailServiceProvider class, the Mailer object is made using three things: a view factory, the Swift_Mailer, and an optional Event Dispatcher. We can easily access the extra details using Laravel’s Service Container through the app()->get() helper.

$view = app()->get('view');
$events = app()->get('events');
$mailer = new Mailer($view, $swift_mailer, $events);

We also made sure that every email sent with the Mailer includes reply and sender information by setting up the replyTo and from properties.

$mailer->alwaysFrom('from-email', 'from-name');
$mailer->alwaysReplyTo('from-email', 'from-name');

Now, using the new Mailer tool, we can send emails using the credentials we set up during runtime.

$mailer->to('recipient')->send(new SomeMailable());

Making our custom Mailer setup simpler

Now that we've set up our special Mailer, we can either place this code in a Service class or a function that gives us the ready-to-use Mailer object. A smarter approach, though, is to use Laravel's Service Container to create our Mailer whenever we want. In our AppServiceProvider class, we can make a new connection with a chosen key (like "user.mailer" in my example) to easily access our customized Mailer.

// AppServiceProvider.class

public function register()
{
$this->app->bind('user.mailer', function ($app, $parameters) {
$smtp_host = array_get($parameters, 'smtp_host');
$smtp_port = array_get($parameters, 'smtp_port');
$smtp_username = array_get($parameters, 'smtp_username');
$smtp_password = array_get($parameters, 'smtp_password');
$smtp_encryption = array_get($parameters, 'smtp_encryption');

$from_email = array_get($parameters, 'from_email');
$from_name = array_get($parameters, 'from_name');

$from_email = $parameters['from_email'];
$from_name = $parameters['from_name'];

$transport = new Swift_SmtpTransport($smtp_host, $smtp_port);
$transport->setUsername($smtp_username);
$transport->setPassword($smtp_password);
$transport->setEncryption($smtp_encryption);

$swift_mailer = new Swift_Mailer($transport);

$mailer = new Mailer($app->get('view'), $swift_mailer, $app->get('events'));
$mailer->alwaysFrom($from_email, $from_name);
$mailer->alwaysReplyTo($from_email, $from_name);

return $mailer;
});
}

Once we set up the connection, whenever we want to use our customer Mailer, we can rely on the Service Container to create it for us with the right settings.

$configuration = [
'smtp_host' => 'SMTP-HOST-HERE',
'smtp_port' => 'SMTP-PORT-HERE',
'smtp_username' => 'SMTP-USERNAME-HERE',
'smtp_password' => 'SMTP-PASSWORD-HERE',
'smtp_encryption' => 'SMTP-ENCRYPTION-HERE',

'from_email' => 'FROM-EMAIL-HERE',
'from_name' => 'FROM-NAME-HERE',
];

$mailer = app()->makeWith('user.mailer', $configuration);

// Use $mailer here...

Caveats

In Laravel, you can schedule emails to be sent later using Mailables and the project's queue system. However, when you queue an email with your own Mailer, it might be sent with the project's mail credentials instead of your custom ones. To avoid this, you can make sure that Mailables using your custom credentials are not queued by default. To do this, just remove the ShouldQueue feature from your Mailable classes.

class SomeMailable extends Mailable implements ShouldQueue
{
// Mailable code here
}

or

class SomeMailable extends Mailable
{
// Mailable code here
}

Next, we're going to make a Job class that can be put in a queue and will use our special Mailer inside. This class will be called UserMailerJob, and it will get our custom settings, the email recipients, and the Mailable object that we want to send.

class UserMailerJob implements ShouldQueue
{
use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;

public $configuration;
public $to;
public $mailable;

/**
* Create a new job instance.
*
* @param array $configuration
* @param string $to
* @param Mailable $mailable
*/
public function __construct(array $configuration, string $to, Mailable $mailable)
{
$this->configuration = $configuration;
$this->to = $to;
$this->mailable = $mailable;
}

/**
* Execute the job.
*
* @return void
*/
public function handle()
{
$mailer = app()->makeWith('user.mailer', $this->configuration);
$mailer->to($this->to)->send($this->mailable);
}
}

Having this job ready allows us to use our UserMailerJob to send emails using our project's queue system.

$configuration = [
'smtp_host' => 'SMTP-HOST-HERE',
'smtp_port' => 'SMTP-PORT-HERE',
'smtp_username' => 'SMTP-USERNAME-HERE',
'smtp_password' => 'SMTP-PASSWORD-HERE',
'smtp_encryption' => 'SMTP-ENCRYPTION-HERE',

'from_email' => 'FROM-EMAIL-HERE',
'from_name' => 'FROM-NAME-HERE',
];

UserMailerJob::dispatch($configuration, 'recipient', new SomeMailable());

Conclusion

Using this arrangement, we're able to send emails with personalized settings adjusted while the program is running. What's great about this approach is that we didn't need to use external tools specifically designed for this task. Instead, we utilized the same elements and coordination that Laravel uses internally to dispatch emails. This is just one of the various ways you can address this kind of need.