Design Patterns in Laravel 11

https://laraveldaily.com/lesson/design-patterns/
Admin
A comprehensive course teaching design patterns in Laravel, including the Action/Command pattern for...
Tokens:8,937
Snippets:117
Trust Score:9.3
Update:6 months ago
Show doc for...
Tokens:
Raw
### Create a Livewire Volt Component

Source: https://laraveldaily.com/lesson/design-patterns/mvc-default

This example shows a self-contained Livewire Volt component within a single Blade file. It defines state, a method, and the component's view. No separate controller or JavaScript is needed.

```php
<?php

use function Livewire\Volt\state;

state(['count' => 0]);

$increment = fn () => $this->count++;

?>

<div>
    <h1>{{ $count }}</h1>
    <button wire:click="increment">+</button>
</div>
```

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

### MailMessage Notification Construction

Source: https://laraveldaily.com/lesson/design-patterns/builder-pattern

Example of building a MailMessage object using fluent method chaining.

```php
public function toMail(object $notifiable): MailMessage
{
    $url = url('/invoice/'.$this->invoice->id);

    return (new MailMessage)
        ->greeting('Hello!')
        ->line('One of your invoices has been paid!')
        ->lineIf($this->amount > 0, "Amount paid: {$this->amount}")
        ->action('View Invoice', $url)
        ->line('Thank you for using our application!');
}
```

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

### Registering Manager Singletons in Laravel

Source: https://laraveldaily.com/lesson/design-patterns/manager-authmanager

Examples of registering various manager classes as singletons within the Laravel service container.

```php
$this->app->singleton('auth', fn ($app) => new AuthManager($app));
 
$this->app->singleton('mail.manager', function ($app) {
    return new MailManager($app);
});
 
$this->app->singleton('cache', function ($app) {
    return new CacheManager($app);
});
```

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

### Creating a Laravel View with Builder Pattern

Source: https://laraveldaily.com/lesson/design-patterns/builder-view-validation-relationships

This example demonstrates the Builder pattern in a Laravel controller when creating a view. The `with()` method returns `$this`, allowing for method chaining.

```PHP
return view('greeting')
    ->with('name', 'Victoria')
    ->with('occupation', 'Astronaut');
```

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

### Retrieving Authenticated User

Source: https://laraveldaily.com/lesson/design-patterns/singleton-auth-mail-cache

These examples show how to access the authenticated user instance, which is managed by the 'auth' singleton. Using `Auth::user()` or `auth()->user()` will always return the same, pre-resolved user object.

```php
Auth::user()
auth()->user()
```

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

### Implementing FactoryContract in Laravel Managers

Source: https://laraveldaily.com/lesson/design-patterns/factory-factorycontract

Examples of how core Laravel managers implement the FactoryContract interface to ensure consistent factory behavior.

```php
use Illuminate\Contracts\Auth\Factory as FactoryContract;
 
class AuthManager implements FactoryContract
{
    // ...
}
```

```php
use Illuminate\Contracts\Mail\Factory as FactoryContract;
 
class MailManager implements FactoryContract
{
    // ...
}
```

```php
use Illuminate\Contracts\Cache\Factory as FactoryContract;
 
class CacheManager implements FactoryContract
{
    // ...
}
```

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

### Define Routes using Route Facade

Source: https://laraveldaily.com/lesson/design-patterns/facade-route-db-gate

Use the Route facade to define various types of routes in your Laravel application, such as resource, GET, POST, and grouped routes.

```php
Route::resource(...);
Route::get(...);
Route::post(...);
Route::group(...);
```

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

### Compare Facade Usage with Manual Instantiation and Dependency Injection

Source: https://laraveldaily.com/lesson/design-patterns/facade-pattern

Demonstrates the difference between manually instantiating a class, using dependency injection, and utilizing a Laravel Facade for the same operation.

```php

use Illuminate\Auth\AuthManager;
 
public function index()
{
    $auth = new AuthManager();
    $user = $auth->user();
}

```

```php

use Illuminate\Auth\AuthManager;
 
public function index(AuthManager $auth)
{
    $user = $auth->user();
}

```

```php

public function index()
{
    $user = Auth::user();
}

```

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

### Instantiate Route Class (without Facade)

Source: https://laraveldaily.com/lesson/design-patterns/facade-route-db-gate

This demonstrates how a route would be defined if not using the Facade pattern, requiring manual instantiation of the Route class.

```php
(new Route)->get(...);
```

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

### Route Facade Implementation

Source: https://laraveldaily.com/lesson/design-patterns/facade-route-db-gate

Examine the source code of the Route facade, showing its extension of the base Facade class and the implementation of getFacadeAccessor to return the service container key.

```php
class Route extends Facade
{
    /**
     * Get the registered name of the component.
     *
     * @return string
     */
    protected static function getFacadeAccessor()
    {
        return 'router';
    }
}
```

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

### Import Route Facade

Source: https://laraveldaily.com/lesson/design-patterns/facade-route-db-gate

Include the necessary 'use' statement to import the Route facade for use in your application.

```php
use Illuminate\Support\Facades\Route;
```

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

### Registering and Using the ExportManager

Source: https://laraveldaily.com/lesson/design-patterns/manager-authmanager

Registering the manager as a singleton and invoking a specific driver through the manager instance.

```php
$this->app->singleton('export', function ($app) {
    return new ExportManager($app);
});
```

```php
$export = app('export');
$export->driver('csv')->parse('file.csv');
```

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

### Implement an Event Listener

Source: https://laraveldaily.com/lesson/design-patterns/observer-pattern

Handle the Registered event to perform secondary actions, such as creating a team for the new user.

```php

use App\Models\Team;
use Illuminate\Auth\Events\Registered;
	
// ...
	
class CreateTeamListener
{
    public function handle(Registered $event): void
    {
        // Access the user using $event->user...
        Team::create([
            'name' => $event->user->name . "'s Team",
            'user_id' => $event->user->id,
        ]);
    }
}
```

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

### Implementing a Driver Class

Source: https://laraveldaily.com/lesson/design-patterns/manager-authmanager

A sample driver class responsible for performing specific tasks, such as parsing a CSV file.

```php
class CsvParser
{
    public function parse(string $path): array
    {
        $file = fopen($path, 'r');
 
        // Do the parsing here
 
        fclose($file);
 
        return $rows;
    }
}
```

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

### PublishPostController with Action Injection

Source: https://laraveldaily.com/lesson/design-patterns/action-command-pattern

Demonstrates injecting an Action class into a controller's __invoke method and dispatching jobs directly from the controller.

```php

use App\Actions\PublishPostAction; 
use App\Models\Post;
use App\Jobs\CreateOgImageJob;
use App\Jobs\TweetPostJob;

class PublishPostController
{
    public function __invoke(Post $post, PublishPostAction $publishPostAction)
    {
        $publishPostAction->execute($post); 

        dispatch(new CreateOgImageJob($post));
        dispatch(new TweetPostJob($post));

        return view('front.posts.published');
    }
}
```

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

### Registering Auth Services as Singletons

Source: https://laraveldaily.com/lesson/design-patterns/singleton-auth-mail-cache

This code registers the 'auth' and 'auth.driver' services as singletons using the application's `singleton` method. This ensures that only one instance of the AuthManager and its guard is created and reused.

```php
protected function registerAuthenticator()
{
    $this->app->singleton('auth', fn ($app) => new AuthManager($app));

    $this->app->singleton('auth.driver', fn ($app) => $app['auth']->guard());
}
```

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

### Eloquent Query Builder Usage

Source: https://laraveldaily.com/lesson/design-patterns/builder-pattern

Demonstrates method chaining to construct a database query using Eloquent.

```php
$user = User::query()
    ->where('is_active', 1)
    ->orderBy('updated_at', 'desc')
    ->first();
```

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

### Basic Laravel Repository Implementation

Source: https://laraveldaily.com/lesson/design-patterns/repository-pattern

Shows a simple implementation of a UserRepository class in Laravel, which delegates database queries to Eloquent models. This is often criticized for adding unnecessary abstraction.

```PHP
class UserRepository
{
    public function find($id)
    {
        return User::find($id);
    }
}
```

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

### Typical Laravel Controller Using Repository

Source: https://laraveldaily.com/lesson/design-patterns/repository-pattern

Demonstrates a common, though often debated, implementation of the Repository pattern within a Laravel controller. This pattern is typically used to abstract data access logic.

```PHP
namespace App\Http\Controllers;
 
use App\Repositories\UserRepository;
use Illuminate\View\View;
 
class UserController extends Controller
{
    public function __construct(
        protected UserRepository $users,
    ) {}
 
    public function show(string $id): View
    {
        $user = $this->users->find($id);
 
        return view('user.profile', ['user' => $user]);
    }
}
```

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

### Implement a standard Controller method

Source: https://laraveldaily.com/lesson/design-patterns/mvc-default

A typical controller method that retrieves data from a model and returns a view.

```php

public function index(): View // CONTROLLER METHOD
{
    $tasks = Task::all(); // USING MODEL METHOD

    return view('tasks.index', compact('tasks')); // CALLING THE VIEW
}

```

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

### Injecting TwitterService into UserService via Type-Hinting

Source: https://laraveldaily.com/lesson/design-patterns/service-pattern

Demonstrates injecting another service (TwitterService) into UserService using type-hinting for external API interactions.

```php
use app\Services\TwitterService;

class UserService {

    public function store(array $userData, TwitterService $twitter): User
    {
                $twitter->tweet()
        }
}
```

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

### Injecting TwitterService into UserService via Constructor

Source: https://laraveldaily.com/lesson/design-patterns/service-pattern

Shows how to inject TwitterService into UserService using constructor property promotion for cleaner dependency management.

```php
use app\Services\TwitterService;

class UserService {

        public function __construct(private readonly TwitterService $twitter){}

    public function store(array $userData): User
    {
                $twitter->tweet()
        }
}
```

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

### Dispatching Laravel Jobs with Delay

Source: https://laraveldaily.com/lesson/design-patterns/action-command-pattern

Demonstrates how to dispatch jobs using the `dispatch` helper. The `TweetPostJob` is delayed by 20 seconds.

```PHP
dispatch(new CreateOgImageJob($post));
dispatch(new TweetPostJob($post))->delay(now()->addSeconds(20));
```

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

### Register a Volt Route in Laravel

Source: https://laraveldaily.com/lesson/design-patterns/mvc-default

Use the Volt::route helper to map a URL to a Livewire Volt component. This is typically defined in your Laravel routes file.

```php
Volt::route('/counter', 'counter');
```

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

### UserService Class for User Operations

Source: https://laraveldaily.com/lesson/design-patterns/service-pattern

Contains methods for storing and updating user data, including role synchronization and additional actions.

```php
namespace App\Services;

class UserService {

    public function store(array $userData): User
    {
        $user = User::create($userData);

        $user->roles()->sync($userData['roles']);

        // More actions with that user: let's say, 5+ more lines of code
        // - Upload avatar
        // - Email to the user
        // - Notify admins about new user
        // - Create some data for that user
        // - and more...

        return $user;
    }

    public function update(array $userData, User $user): User
    {
        $user->update($userData);
        $user->roles()->sync($userData['roles']);

        // Also, more actions with that user
    }
}
```

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

### Define a Custom Event Class

Source: https://laraveldaily.com/lesson/design-patterns/observer-pattern

Create an event class that holds the user model as a property for listeners to access.

```php

use Illuminate\Queue\SerializesModels;
	
class Registered
{
    use SerializesModels;
	
    public $user;
	
    public function __construct($user)
    {
        $this->user = $user;
    }
}
```

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

### Define a route for a static view

Source: https://laraveldaily.com/lesson/design-patterns/mvc-default

A route definition that renders a view directly without requiring a controller or model.

```php

Route::view('about-us', 'pages.about');

```

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

### Resolving TwitterService from Service Container

Source: https://laraveldaily.com/lesson/design-patterns/service-pattern

Illustrates resolving a service (TwitterService) from the application's service container without explicit type-hinting in the method signature.

```php
use app\Services\TwitterService;

class UserService {
    public function store(array $userData): User
    {
                $twitter= app(UserService::class);
                $twitter->tweet()
        }
}
```

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

### AuthManager Constructor and User Resolver

Source: https://laraveldaily.com/lesson/design-patterns/singleton-auth-mail-cache

The constructor for `AuthManager` initializes the application instance and sets up a user resolver. This resolver is a closure that will be used to fetch the authenticated user, ensuring it's resolved only when needed and reused.

```php
/**
 * Create a new Auth manager instance.
 *
 * @param  \Illuminate\Contracts\Foundation\Application  $app
 * @return void
 */
public function __construct($app)
{
    $this->app = $app;

    $this->userResolver = fn ($guard = null) => $this->guard($guard)->user();
}
```

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

### Illuminate/View/View.php Source Code

Source: https://laraveldaily.com/lesson/design-patterns/builder-view-validation-relationships

This is the source code for the `with()` method in Laravel's `Illuminate/View/View.php` class. It returns `$this`, which is characteristic of the Builder pattern, enabling method chaining.

```PHP
public function with($key, $value = null)
{
    if (is_array($key)) {
        $this->data = array_merge($this->data, $key);
    } else {
        $this->data[$key] = $value;
    }
 
    return $this;
}
```

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

### Inject TwitterService into Controller

Source: https://laraveldaily.com/lesson/design-patterns/services-interfaces-injection-strategy

Demonstrates injecting the TwitterService into a controller's __invoke method to handle post-publishing logic.

```php

use App\Models\Post;
use App\Services\TwitterService;
 
class PublishPostController
{
    public function __invoke(Post $post, TwitterService $twitter)
    {
        // ... all other operations with `$post`
 
        $tweetResponse = $twitter->tweet($tweetText); 
 
        if (! isset($tweetResponse['data']->id)) {
            return;
        }
 
        $tweetUrl = "https://twitter.com/freekmurze/status/{$tweetResponse['data']->id}";
 
        $post->onAfterTweet($tweetUrl);

        $post->update(['tweet_sent' => true]);
    }
}
```

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

### Refactored Controller with Action-Only Logic

Source: https://laraveldaily.com/lesson/design-patterns/action-command-pattern

A simplified controller that delegates all post-publishing logic to the Action class.

```php

use App\Actions\PublishPostAction;
use App\Models\Post;

class PublishPostController
{
    public function __invoke(Post $post, PublishPostAction $publishPostAction)
    {
        $publishPostAction->execute($post);

        return view('front.posts.published');
    }
}
```

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

### Implement TwitterService Class

Source: https://laraveldaily.com/lesson/design-patterns/services-interfaces-injection-strategy

A service class implementation that uses a third-party package to interact with the Twitter API, restricted to production environments.

```php

namespace App\Services;
 
use Abraham\TwitterOAuth\TwitterOAuth;
 
class TwitterService
{
    public function tweet(string $text): ?array
    {
        if (! app()->environment('production')) {
            return null;
        }
 
        $twitter = new TwitterOAuth(
            config('services.twitter.consumer_key'),
            config('services.twitter.consumer_secret'),
            config('services.twitter.access_token'),
            config('services.twitter.access_token_secret')
        );
 
        return (array) $twitter->post('tweets', compact('text'));
    }
}
```

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

### Action Class with Internal Job Dispatching

Source: https://laraveldaily.com/lesson/design-patterns/action-command-pattern

An Action class that handles business logic and dispatches related background jobs internally.

```php

namespace App\Actions;

use App\Jobs\CreateOgImageJob;
use App\Jobs\TweetPostJob;
use App\Models\Post;

class PublishPostAction
{
    public function execute(Post $post)
    {
        $post->published = true;

        if (! $post->publish_date) {
            $post->publish_date = now();
        }

        $post->save();

        dispatch(new CreateOgImageJob($post));
        dispatch(new TweetPostJob($post))->delay(now()->addSeconds(20));

        // ... dispatch whatever other Jobs
    }
}
```

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

### Eloquent where Method Implementation

Source: https://laraveldaily.com/lesson/design-patterns/builder-pattern

Shows the internal implementation of the where method, which returns $this to support chaining.

```php
/**
 * Add a basic where clause to the query.
 *
 * @param  \Closure|string|array|\Illuminate\Database\Query\Expression  $column
 * @param  mixed  $operator
 * @param  mixed  $value
 * @param  string  $boolean
 * @return $this
 */
public function where($column, $operator = null, $value = null, $boolean = 'and')
{
    if ($column instanceof Closure && is_null($operator)) {
        $column($query = $this->model->newQueryWithoutRelationships());

        $this->query->addNestedWhereQuery($query->getQuery(), $boolean);
    } else {
        $this->query->where(...func_get_args());
    }

    return $this;
}
```

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

### SimpleMessage Class Implementation

Source: https://laraveldaily.com/lesson/design-patterns/builder-pattern

Internal structure of a builder class showing how methods return $this to enable chaining.

```php
class SimpleMessage
{
    public $greeting;

    public $actionText;

    public $actionUrl;

    // ... more properties and methods

    public function greeting($greeting)
    {
        $this->greeting = $greeting;

        return $this;
    }

    public function action($text, $url)
    {
        $this->actionText = $text;
        $this->actionUrl = $url;

        return $this;
    }
}
```

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

### Define a route for a JavaScript-heavy application

Source: https://laraveldaily.com/lesson/design-patterns/mvc-default

A route that loads a main view, often used in SPA or front-end heavy architectures where logic resides in JavaScript.

```php

Route::view('/', 'main');

```

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

### Monolithic Controller Logic

Source: https://laraveldaily.com/lesson/design-patterns/action-command-pattern

This controller method handles multiple distinct operations: updating model data, preparing an OG image, and posting a tweet. It demonstrates a common anti-pattern of placing too much logic within a single controller.

```php
use App\Models\Post;
use App\Services\TwitterService;
use Spatie\Browsershot\Browsershot;
 
class PublishPostController
{
    public function __invoke(Post $post, TwitterService $twitter)
    {
        // =======================
        // Step 1. Publish a post
        // =======================
 
        $post->published = true;
 
        if (! $post->publish_date) {
            $post->publish_date = now();
        }
 
        $post->save();
 
        // ============================================ 
        // Step 2. Create OG Image for Social Networks
        // ============================================ 
 
        if (!$post->isTweet()) {
            $base64Image = Browsershot::url($post->ogImageBaseUrl())
                ->devicePixelRatio(2)
                ->windowSize(1200, 630)
                ->base64Screenshot();
 
            $post
                ->addMediaFromBase64($base64Image)
                ->usingFileName("{$post->id}.png")
                ->toMediaCollection('ogImage');
        }
 
        // =======================
        // Step 3. Tweet the Post
        // =======================
 
        if ($post->send_automated_tweet && !$post->isTweet() && !post->tweet_sent) {
            $tweetText = $post->toTweet();
 
            $tweetResponse = $twitter->tweet($tweetText);
 
            if (! isset($tweetResponse['data']->id)) {
                return;
            }
 
            $tweetUrl = "https://twitter.com/freekmurze/status/{$tweetResponse['data']->id}";
 
            $post->onAfterTweet($tweetUrl);
 
            $post->update(['tweet_sent' => true]);
        }
 
        return view('front.posts.published');
    }
}
```

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

### Defining an ExportManager Class

Source: https://laraveldaily.com/lesson/design-patterns/manager-authmanager

Implementation of a custom manager class extending Illuminate\Support\Manager to handle driver creation.

```php
class ExportManager extends Manager
{
    public function getDefaultDriver()
    {
        return 'csv';
    }
 
    public function createCsvDriver()
    {
        return new CsvParser();
    }
 
    public function createJsonDriver()
    {
        return new JsonParser();
    }
}
```

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

### Store User with UserService in Controller

Source: https://laraveldaily.com/lesson/design-patterns/service-pattern

Injects UserService into a controller method to handle user storage logic, keeping the controller clean.

```php
use App\Http\Requests\StoreUserRequest;
use App\Services\UserService;

class UserController extends Controller
{
    public function store(StoreUserRequest $request, UserService $userService)
    {
        $userService->store($request->validated());

        return redirect()->route('users.index');
    }

    // ...
}
```

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

### Fire an Event in a Controller

Source: https://laraveldaily.com/lesson/design-patterns/observer-pattern

Trigger the Registered event within a controller after creating a user model.

```php

use Illuminate\Auth\Events\Registered;
	
// ...
	
class RegisteredUserController extends Controller
{
    public function store(Request $request): RedirectResponse
    {
        // ... validation
	
        $user = User::create([
            'name' => $request->name,
            'email' => $request->email,
            'password' => Hash::make($request->password),
        ]);
	
        event(new Registered($user)); 
```

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

### Basic Laravel Job Structure

Source: https://laraveldaily.com/lesson/design-patterns/action-command-pattern

This is the default structure for a new Job class generated by Artisan. It includes constructor and handle methods.

```PHP
namespace App\Jobs;
 
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
 
class TweetPostJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
 
    /**
     * Create a new job instance.
     */
    public function __construct()
    {
        //
    }
 
    /**
     * Execute the job.
     */
    public function handle(): void
    {
        //
    }
}
```

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

### Implement toMail method for Notifications

Source: https://laraveldaily.com/lesson/design-patterns/adapter-notifications-filesystem

This method transforms notification data into a MailMessage object, acting as an adapter for the email delivery system.

```php
public function toMail($notifiable)
{
    return (new MailMessage)
        ->line('The introduction to the notification.')
        ->action('Link button', route('link'));
}
```

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

### Refactored Controller with Actions and Jobs

Source: https://laraveldaily.com/lesson/design-patterns/action-command-pattern

This refactored controller delegates distinct operations to dedicated Action classes and Jobs. The controller remains clean and readable, focusing on orchestrating these separate components.

```php
use App\Actions\PublishPostAction;
use App\Models\Post;
use App\Jobs\CreateOgImageJob;
use App\Jobs\TweetPostJob;
 
class PublishPostController
{
    public function __invoke(Post $post, PublishPostAction $publishPostAction)
    {
        $publishPostAction->execute($post);
 
        dispatch(new CreateOgImageJob($post));
        dispatch(new TweetPostJob($post));
 
        return view('front.posts.published');
    }
}
```

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

### PublishPostAction Class Definition

Source: https://laraveldaily.com/lesson/design-patterns/action-command-pattern

A standard Action class implementation for updating post status without implementing specific interfaces.

```php

namespace App\Actions;

use App\Models\Post;

class PublishPostAction
{
    public function execute(Post $post)
    {
        $post->published = true;

        if (! $post->publish_date) {
            $post->publish_date = now();
        }

        $post->save();
    }
}
```

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

### CreateOgImageJob Class in Laravel

Source: https://laraveldaily.com/lesson/design-patterns/action-command-pattern

This job class generates an OG image for a post using Browsershot. It implements ShouldQueue and has a retry count of 2.

```PHP
namespace App\Jobs;
 
use App\Models\Post;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
use Spatie\Browsershot\Browsershot;
 
class CreateOgImageJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
 
    public $tries = 2;
 
    public function __construct(
        public Post $post
    ) {}
 
    public function handle(): void
    {
        if ($this->post->isTweet()) {
            return;
        }
 
        $base64Image = Browsershot::url($this->post->ogImageBaseUrl())
            ->devicePixelRatio(2)
            ->windowSize(1200, 630)
            ->base64Screenshot();
 
        $this
            ->post
            ->addMediaFromBase64($base64Image)
            ->usingFileName("{$this->post->id}.png")
            ->toMediaCollection('ogImage');
    }
}
```

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

### TweetPostJob Class in Laravel

Source: https://laraveldaily.com/lesson/design-patterns/action-command-pattern

This job class tweets about a post using an external TwitterService. It checks several conditions before sending the tweet and updates the post status.

```PHP
namespace App\Jobs;
 
use App\Models\Post;
use App\Services\TwitterService;
use Illuminate\Bus\Queueable;
use Illuminate\Contracts\Queue\ShouldQueue;
use Illuminate\Foundation\Bus\Dispatchable;
use Illuminate\Queue\InteractsWithQueue;
use Illuminate\Queue\SerializesModels;
 
class TweetPostJob implements ShouldQueue
{
    use Dispatchable, InteractsWithQueue, Queueable, SerializesModels;
 
    public function __construct(
        public Post $post
    ) {}
 
    public function handle(TwitterService $twitter): void
    {
        if (! $this->post->send_automated_tweet) {
            return;
        }
 
        if ($this->post->tweet_sent) {
            return;
        }
 
        if ($this->post->isTweet()) {
            return;
        }
 
        $tweetText = $this->post->toTweet();
 
        $tweetResponse = $twitter->tweet($tweetText);
 
        if (! isset($tweetResponse['data']->id)) {
            return;
        }
 
        $tweetUrl = "https://twitter.com/freekmurze/status/{$tweetResponse['data']->id}";
 
        $this->post->onAfterTweet($tweetUrl);
 
        $this->post->update(['tweet_sent' => true]);
    }
}
```
Tokens:
Raw