DEV Community: Paulund

Extend Laravel Optimize Command

Paulund — Sun, 09 Feb 2025 12:32:38 +0000

The Laravel Optimize command is a command that is used to optimize the Laravel application. It is used to optimize the
application by compiling the application's configuration files, routes, and views into a single file.

This command is used to improve the performance of the Laravel application by reducing the number of files that need to
be loaded when the application is running.

It is good practice to use this command when deploying the Laravel application to a production environment.

php artisan optimize

Under the hood, the optimize command is calling the optimize method of the OptimizeCommand class. This class is
located in the Illuminate\Foundation\Console namespace.

It will run the following commands:

$this->call('config:cache');
$this->call('event:cache');
$this->call('route:cache');
$this->call('view:cache');

But there is a way you can extend this command by adding your own custom commands into the optimize command.

For example lets say you want tp run a command on deployment that will generate a new sitemap
php artisan sitemap:generate and you want to run this command when you run php artisan optimize command.

To do this you can add a new command into the ServiceProviders to add into the optimize command. This is done by
using the new optimizes method that is available in version Laravel v11.27.1.

public function boot(): void
{
    $this->optimizes(
        optimize: SitemapGenerateCommand::class,
    );
}

Now this will run the SitemapGenerateCommand command when you run php artisan optimize command.

Prunable Eloquent Models

Paulund — Fri, 06 Dec 2024 22:02:32 +0000

Since Laravel 8.5 there was a trait added to the framework that will allow you to prune models based on a date. This
trait is called Illuminate\Database\Eloquent\Prunable and it will allow you to prune models based on a date.

This trait is useful when you have models that you want to delete based on a date. For example, you might have a model
that stores logs and you want to delete logs that are older than a certain date.

In this article, we're going to look at how you can create a trait that will allow you to prune models based on a date.

Using the Prunable Trait

To use the Prunable trait you need to add it to your model and define a prunable method that will return a query
builder instance. This query builder instance will be used to prune the models based on a date.

Here's an example of how you can use the Prunable trait in a model:

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;
use Illuminate\Database\Eloquent\Prunable;

class Log extends Model
{
    use Prunable;

    public function prunable()
    {
        return $this->where('created_at', '<', now()->subDays(30));
    }
}

In this example, we have a Log model that uses the Prunable trait. We have defined a prunable method that returns
a query builder instance that will delete logs that are older than 30 days.

Schedule Pruning

To prune the models you need to schedule the pruning to run at a certain time. You can do this by adding a command
to your routes/console.php file that will call the prune method on the model.

Here's an example of how you can schedule the pruning of the Log model:

<?php

use Illuminate\Support\Facades\Schedule;

Schedule::command('model:prune')->daily();

In this example, we're scheduling the model:prune command to run daily. This command will call the prune method
on the Log model and delete logs that are older than 30 days.

Laravel Create Virtual Database Column

Paulund — Sun, 23 Jun 2024 06:42:04 +0000

In this article we're going to learn how to create a virtual database column in Laravel.

Why Use Virtual Columns?

Virtual columns are useful when you want to add a column to a model that doesn't exist in the database. This can be useful for things like computed columns, or for columns that are derived from other columns.

I recently had a situation where I needed to add a virtual column to a model that was derived from other columns in the model. I didn't want to store this column in the database, as it would be redundant and would require additional maintenance.

This was from a JSON blob column that I needed to search for a value in. I didn't want to extract this and store this separately in another column as I need this to stay in sync with the JSON blob. But I wanted to search for this column and be able to index the column for performance improvements rather than searching the JSON blob.

Creating a Virtual Column

To create a new virtual column in MySQL from a JSON blob column, you can use the JSON_EXTRACT function. This function allows you to extract a value from a JSON blob column and use it as a virtual column.

Here's an example of how you can create a virtual column in MySQL:

ALTER TABLE `users` ADD COLUMN `email` VARCHAR(255) GENERATED ALWAYS AS (JSON_UNQUOTE(JSON_EXTRACT(`data`, '$.email'))) VIRTUAL;

In this example, we're adding a new virtual column called email to the users table. This column is derived from the data column, which is a JSON blob column. We're using the JSON_EXTRACT function to extract the email field from the JSON blob and store it in the email column.

Using Virtual Columns in Laravel

First we need to create the migration to add the virtual column to the table. Here's an example of how you can create a migration to add a virtual column to a table in Laravel:

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

class AddVirtualColumnToUsersTable extends Migration
{
    public function up()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->string('email')->virtualAs("JSON_UNQUOTE(JSON_EXTRACT(`data`, '$.email'))");
        });
    }

    public function down()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->dropColumn('email');
        });
    }
}

In this example, we're creating a new migration called AddVirtualColumnToUsersTable that adds a virtual column called email to the users table. We're using the virtualAs method to specify the expression that should be used to generate the virtual column.

Once you've created the migration, you can run it using the php artisan migrate command. This will add the virtual column to the table.

Use In Laravel

Now that we have the virtual column added to the table, we can use it in our Laravel application like any other column.

$user = User::where('email', 'test@email.com')->first();

In this example, we're using the virtual column email to search for a user with the email address.

You can also access this column like any other column in your model:

$user = User::find(1);
echo $user->email;

In this example, we're accessing the email virtual column on the User model.

Conclusion

In this article, we've learned how to create a virtual database column in Laravel. Virtual columns are useful when you want to add a column to a model that doesn't exist in the database. This can be useful for things like computed columns, or for columns that are derived from other columns.

Laravel Polymorphic Models By Type

Paulund — Thu, 30 May 2024 08:51:20 +0000

I needed a better way of handling different model types based on a single database table.

The example I had was that there was a settings table for the application that can return different types of settings based on the type column of the row.

Schema::create('settings', function (Blueprint $table) {
    $table->id();
    $table->string('type');
    $table->text('settings');
    $table->timestamps();
});

The type column would be used to determine the type of setting that was being stored in the settings column. Which can be something like email, slack, sms etc. The settings column would be a JSON column that would store the settings for the notification type such as the email to send or the token and channel to send the slack notification.

Because the value of the settings column can consist of different types of settings I needed a way to handle this in the application. I wanted different classes to use for each type of setting, such as EmailSetting, SlackSetting, SmsSetting etc.

The EmailSetting will have a method getEmail to get the email in the settings json column.

<?php

namespace App\Models\Notifications;

use Illuminate\Database\Eloquent\Model;

class EmailSetting extends Model
{
    public function getEmail()
    {
        return $this->settings['email'] ?? '';
    }
}

While the SlackSetting class will have a method getChannel to get the channel in the settings json column and a getToken to get the API token.

<?php

namespace App\Models\Notifications;

use Illuminate\Database\Eloquent\Model;

class SlackSetting extends Model
{
    public function getChannel()
    {
        return $this->settings['channel'] ?? '';
    }

    public function getToken()
    {
        return $this->settings['token'] ?? '';
    }
}

Polymorphic Relationship

To handle this I used a polymorphic relationship in Laravel to handle the different types of settings. I created a Setting model that would be used to handle the different types of settings.

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Model;

class Setting extends Model
{
    public function notification()
    {
        return $this->morphTo('type', 'type', 'id');
    }
}

The notification method is a polymorphic relationship that will return the correct model based on the type column of the settings table.

In order to tell Laravel which model to use for each type we need to add a morphMap to the AppServiceProvider class.

<?php

namespace App\Providers;

class AppServiceProvider extends ServiceProvider
{
    public function boot()
    {
        Relation::morphMap([
            'email' => EmailSetting::class,
            'slack' => SlackSetting::class,
        ]);
    }
}

The morphMap method will map the email and slack types to the EmailSetting and SlackSetting classes respectively.

Now when you retrieve a setting from the database you can access the correct model based on the type column.

$setting = Setting::find(1);

if($setting->type === 'email') {
    $email = $setting->notification->getEmail();
}

if($setting->type === 'slack') {
    $channel = $setting->notification->getChannel();
    $token = $setting->notification->getToken();
}

But with this you will get an error when you try to use ->notification as it will try to access the the email_settings table that doesn't exist.

To fix this you need to tell the EmailSetting model what table to use by using the method getTable.

public function getTable()
{
    return 'settings';
}

This will tell the EmailSetting model to use the settings table instead of the email_settings table and return the right model for you when you use the notification settings.

This is how you can use polymorphic models by type in Laravel to handle different types of settings in a single database table. This can be useful when you have different types of settings that you need to handle in your application.

Laravel Immutable Carbon Dates

Paulund — Wed, 29 May 2024 09:35:24 +0000

In this article we're going to look at the Carbon data class in laravel and how we can change the settings of how laravel uses the class to make it immutable.

What's the problem we're trying to solve?

When you're working with dates in Laravel you will most likely be using the Carbon class. This class is a wrapper around the PHP DateTime class and provides a lot of useful methods for working with dates.

When you output the value of a carbon object you get this value.

$now = now()
= Illuminate\Support\Carbon @1716793925 {#5324
    date: 2024-05-27 08:13:50.554997 Europe/London (+01:00),
  }

You can change this object by adding or subtracting time from the object with helper helpers like ->addHour().

$now = $now->addHour()
= Illuminate\Support\Carbon @1716797621 {#5329
    date: 2024-05-27 09:13:50.554997 Europe/London (+01:00),
  }

You can add multiple hours by using the method ->addHours(4).

$now = $now->addHours(4)
= Illuminate\Support\Carbon @1716812090 {#5318
    date: 2024-05-27 13:13:50.554997 Europe/London (+01:00),
  }

But we have a problem, adding 4 hours to 8:12 should be 12:12 not 13:13. This is because the Carbon class is mutable and when you call the addHours method it changes the original object.

This can have it's advantages when you have a large process of changing the date multiple times but it can also have it' s disadvantages when you want to keep the original date.

Carbon has a method called copy that will create a new instance of the Carbon object and then you can change the new object.

$now = now()
= Illuminate\Support\Carbon @1716793925 {#5324
    date: 2024-05-27 08:13:50.554997 Europe/London (+01:00),
  }

$nowCopy = $now->copy()->addHours(4)
= Illuminate\Support\Carbon @1716812090 {#5318
    date: 2024-05-27 12:13:50.554997 Europe/London (+01:00),
  }

The other approach is to use the CarbonImmutable class which is a subclass of the Carbon class but it's immutable.

$now = Carbon\CarbonImmutable::now();
= Carbon\CarbonImmutable @1716794377 {#5341
    date: 2024-05-27 08:19:37.149971 Europe/London (+01:00),
  }

$now->addHour()
= Carbon\CarbonImmutable @1716797977 {#5394
    date: 2024-05-27 09:19:37.149971 Europe/London (+01:00),
  }

$now->addHours(4)
= Carbon\CarbonImmutable @1716808777 {#5335
    date: 2024-05-27 12:19:37.149971 Europe/London (+01:00),
  }

As you can see when we add 1 hour and then 4 hours we get the result of 4 hours not 5 hours. Now we get the expected results when working with dates.

This is a simple change to make in your application but it can have a big impact on how you work with dates in your application.

Changing the default Carbon class

If you want to change the default Carbon class to be immutable you can do this by adding the following code to your AppServiceProvider class.

use Carbon\CarbonImmutable;
use Illuminate\Support\Facades\Date;

public function boot()
{
    Date::use(CarbonImmutable::class);
}

This will change the default Carbon class to be CarbonImmutable and now all dates in your application will be immutable.

This is a simple change to make in your application but it can have a big impact on how you work with dates in your application.

Performance Implications

There are some performance implications when using the CarbonImmutable class. The CarbonImmutable class is slower than the Carbon class because it creates a new instance of the object every time you call a method that changes the date.

This is because the CarbonImmutable class is immutable and it doesn't change the original object. This can have a big impact on the performance of your application if you're working with a lot of dates.

You should consider the performance implications when deciding whether to use the CarbonImmutable class or the Carbon class in your application.

Auto Generate Open Graph Images With Laravel

Paulund — Tue, 28 May 2024 08:15:20 +0000

Laravel is a popular PHP framework that makes it easy to build web applications. In this article, we will look at how to auto-generate Open Graph images with Laravel. If you want to use this in your application you can install the Laravel package
Laravel Og Image Generator.

For this functionality we're going to generate the image in the background, cache this image in the local storage and then serve this image to the user. This way we can generate the image once and then serve it to the user without having to generate it every time.

In order to do this we're going to use the package spatie/browsershot that will use the headless browser to generate the image. This will allow us to create a route that the headless browser to use to store the output as a image.

Install Browsershot

The first thing you need to do is install the spatie/browsershot package. This package is a utility for generating images using a headless browser. You can install it using composer.

composer require spatie/browsershot

Create The Route For The Image

Once you have installed the spatie/browsershot package, you can create a new route that will generate the Open Graph image. This route will use the browsershot package to generate the image and store it in the local storage.

Here is an example of how you can create a route that generates an Open Graph image:

Route::get('/og-image', OgImageController::class);

In this example, we are creating a new route that will use the OgImageController to generate the Open Graph image.

Create The Controller

There's a few steps for this controller so we're going to break it down into a few steps.

First we need to create the controller with the invoke method that will generate the image.

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;

class OgImageController extends Controller
{
    public function __invoke(Request $request)
    {

    }
}

We're going to pass in a querystring into the route that we'll use as the title in the generated image. This will make the route look like this:

/og-image?title=Hello%20World

In the controller we need to access this querystring to use as the text in the image we do this by using the $request object.

$request->validate([
    'title' => 'required|string',
]);

$title = $request->get('title');

Generate The HTML From Blade

We need to get the HTML from the blade file as we're going to pass this into the browsershot package, we don't want to return the HTML in the controller but we need render the HTML.

$html = view('ogimage', [
    'title' => $title,
])->render();

Create the blade file in the resources/views directory called ogimage.blade.php with the following content:

<!DOCTYPE html>
<html lang="en">
<head>
    @vite('resources/js/app.js')
</head>
<body>
<div class="border-2 border-gray-800 w-[1200px] h-[630px] bg-gray-900">
    <div class="flex flex-col items-center justify-center h-full w-full bg-cover bg-center bg-no-repeat">
        <h1 class="font-bold text-4xl text-white">{{ $title }}</h1>
    </div>
</div>
</body>
</html>

Notice the @vite directive this is a custom directive that will include the Vite assets in the blade file. You will need to either use your main CSS file or in this case we're using Javascript to import the CSS. Use the one that fits your application.

Generate The Image

Back in the controller we can now generate the image using the browsershot package. We're going to use the browsershot package to generate the image and store it in the local storage.

$slugTitle = Str::slug($title);

$browsershot = Browsershot::html($html)
    ->noSandbox()
    ->showBackground()
    ->windowSize(1200, 630)
    ->setScreenshotType('png');

if (config('ogimage.node_path')) {
    $browsershot->setNodeBinary(config('chrome.node_path'));
}

if (config('ogimage.npm_path')) {
    $browsershot->setNpmBinary(config('chrome.npm_path'));
}

$image = $browsershot->screenshot();

// Store image locally
Storage::disk('local')->put('public/og-images/' . $slugTitle . '.png', $image);

In this example, we take the generated HTML and pass it into the Browsershot package. We set the window size to 1200x630 pixels and set the screenshot type to PNG. We then store the image in the local storage.

Serve The Image

Now that we have generated the image and stored it in the local storage, we can serve this image to the user. We can do this by returning the image from the controller.

return response($image, 200, [
    'Content-Type' => 'image/png',
]);

Checking For Existing Image

The above code will generate the image everytime and store it in the local storage, but we don't need to generate the image everytime. We can check if the image exists and if it does we can return the image from the local storage.

if (Storage::disk('local')->exists('public/og-images/'.$slugTitle.'.png')) {
    return response(Storage::disk('local')->get('public/og-images/'.$slugTitle.'.png'), 200, [
        'Content-Type' => 'image/png',
    ]);
}

We can put this code at the top of the controller and if the image exists we can return the image from the local storage.

Full Controller Code

Below is the full code used in the controller that you can use to generate the ogimage

<?php

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use Illuminate\Routing\Controller;
use Illuminate\Support\Facades\Storage;
use Illuminate\Support\Str;
use Spatie\Browsershot\Browsershot;

class OgImageController extends Controller
{
    public function __invoke(Request $request)
    {
        $request->validate([
            'title' => 'required|string',
        ]);

        $title = $request->get('title');
        $slugTitle = Str::slug($title);

        if ($this->hasImage($slugTitle)) {
            return response($this->getImage($slugTitle), 200, [
                'Content-Type' => 'image/png',
            ]);
        }

        $html = view('ogimage', [
            'title' => $title,
        ])->render();

        $browsershot = Browsershot::html($html)
            ->noSandbox()
            ->showBackground()
            ->windowSize(1200, 630)
            ->setScreenshotType('png');

        if (config('chrome.node_path')) {
            $browsershot->setNodeBinary(config('chrome.node_path'));
        }

        if (config('chrome.npm_path')) {
            $browsershot->setNpmBinary(config('chrome.npm_path'));
        }

        $image = $browsershot->screenshot();

        $this->saveImage($slugTitle, $image);

        return response($image, 200, [
            'Content-Type' => 'image/png',
        ]);
    }

    private function getFilePath($slugTitle)
    {
        return 'public/og-images/'.$slugTitle.'.png';
    }

    private function hasImage($slugTitle)
    {
        return Storage::disk('local')->exists($this->getFilePath($slugTitle));
    }

    private function getImage($slugTitle)
    {
        return Storage::disk('local')->get($this->getFilePath($slugTitle));
    }

    private function saveImage($slugTitle, $image)
    {
        Storage::disk('local')->put($this->getFilePath($slugTitle), $image);
    }
}

Add Meta Tags To Your Site

In order to use this image when posting to social media we need to add the Open Graph meta tags to the site. This will tell the social media platform to use the image we generated.

<meta property="og:title" content="Hello World">
<meta property="og:image" content="/og-image?title=Hello%20World">
<meta property="og:image:width" content="1200">
<meta property="og:image:height" content="630">

In this example, we are setting the title of the post to "Hello World" and the image to the route we created earlier.

Conclusion

In this article, we looked at how to auto-generate Open Graph images with Laravel. We used the spatie/browsershot package to generate the image and store it in the local storage. This allows us to generate the image once and then serve it to the user without having to generate it every time.

This functionality can be useful for generating Open Graph images for blog posts, social media posts, and other content that requires an image.

Display Flash Messages Using Laravel and Inertia

Paulund — Sun, 26 May 2024 07:33:29 +0000

In Laravel it's common practise to after a form submit to redirect the user back to the form page and display a flash
message. In this tutorial we will see how to display flash messages using Laravel and Inertia.

With Laravel you will do this with some helper route methods, in your controller you will have something like this:

return redirect()->back()->with('success', 'Form submitted successfully');

This will add a success key to the session with the value Form submitted successfully. If you're using blade file you can
then display this message like this:

@if (session('success'))
    <div class="alert alert-success">
        {{ session('success') }}
    </div>
@endif

But this won't work with Inertia, because Inertia is a client-side framework and it doesn't have access to the session. So
we need to pass the flash messages to the client side.

To do this we will take advantage of the Inertia middleware HandleInertiaRequests this middleware is responsible for
passing the data to the client side. We will add a new key to the share method in the HandleInertiaRequests middleware
called flash and we will pass the session flash messages to the client side.

// app/Http/Middleware/HandleInertiaRequests.php

public function share(Request $request)
{
    return array_merge(parent::share($request), [
        'flash' => [
            'success' => $request->session()->get('success'),
            'error' => $request->session()->get('error'),
        ],
    ]);
}

These will come through to your Vue components as page props page.props.flash?.success and page.props.flash?.error.

Now in your Vue component you can access the flash messages like this:

<template>
    <div>
        <div v-if="$page.props.flash.success" class="alert alert-success">
            {{ $page.props.flash.success }}
        </div>
        <div v-if="$page.props.flash.error" class="alert alert-danger">
            {{ $page.props.flash.error }}
        </div>
    </div>
</template>

Only Use Env() In Config Files

Paulund — Thu, 23 May 2024 07:55:59 +0000

When working with Laravel you may find yourself needing to access environment variables in your configuration files. In this article we're going to look at how you can access these environment variables using the env() helper function.

We will use the environment variables to have different settings for our application on different machines for example you might want different settings for the app in development and production.

Laravel provides a helper function called env() that allows you to access environment variables in your application. This function takes two arguments the first is the name of the environment variable and the second is the default value if the environment variable is not set.

This will allow you to do things in your application like this:

if(env('APP_DEBUG', false) === true) {
    // Do something
}

But there is a problem with the above code, this will work in development but there will be a problem in production.

In most laravel production applications we use the command php artisan config:cache to cache the configuration files. This will speed up the application as it doesn't need to read the configuration files on every request.

But the problem with the above code is that the env() function will not work when the configuration files are cached. This is because the env() function is a helper function and it will not be executed when the configuration files are cached. You will get a null response from the env() function when the configuration files are cached.

So how do we fix this? The solution is to use the config() function instead of the env() function. The config() function will work when the configuration files are cached.

The config() function works in the same way as the env() function but it will work when the configuration files are cached.

So the above code can be changed to:

if(config('app.debug', false) === true) {
    // Do something
}

This will work in both development and production environments.

In your config files you can use the env() function as this will be used to build the configuration cache like this.

'debug' => env('APP_DEBUG', false),

You can read more about production optimization in the Laravel documentation.

Now you know how to use the env() function in your configuration files in Laravel. This will help you to have different settings for your application on different machines and environments.

Disable Vite During Testing in Laravel

Paulund — Wed, 22 May 2024 08:40:51 +0000

I recently had a project where I wanted github actions to run the tests of a laravel project but i didn't want to install node and vite during the CI process.

When I ran the tests in Github Actions I got the following error

Spatie\LaravelIgnition\Exceptions\ViewException: Vite manifest not found at

I was getting this error because I didn't run npm i && npm run dev before running the tests but because I didn't install node I didn't want to have to run this.

To fix this you can tell your tests to ignore vite by adding the following to your base test case file.

<?php

namespace Tests;

use Illuminate\Foundation\Testing\TestCase as BaseTestCase;

abstract class TestCase extends BaseTestCase
{
    use CreatesApplication;

    protected function setUp(): void
    {
        parent::setUp();

        $this->withoutVite();
    }
}

This will tell your tests to ignore vite and you won't get the error anymore.

Performance Metrics Using Guzzle

Paulund — Mon, 20 May 2024 12:10:43 +0000

In this article we're going to investigate how you can track performance metrics using Guzzle. Guzzle is a PHP HTTP client that makes it easy to send HTTP requests and trivial to integrate with web services.

Introduction

Guzzle is a PHP HTTP client that makes it easy to send HTTP requests and trivial to integrate with web services. It provides a simple interface for building query strings, POST requests, streaming large uploads, streaming large downloads, using HTTP cookies, uploading JSON data, etc.

Installation

To install Guzzle, you can use Composer. Run the following command to install Guzzle:

composer require guzzlehttp/guzzle

Usage

To send a request using Guzzle, you need to create a new Client instance and then use the request method to send
the request. Here's an example:

use GuzzleHttp\Client;

$client = new Client();
$response = $client->request('GET', 'https://example.com/posts/1');

echo $response->getBody();

In this example, we're sending a GET request to https://example.com/posts/1 and then printing the response body.

Performance Metrics

Guzzle provides a way to track performance metrics for each request. You can use the on_stats options to get detailed
information about the request. Here's an example:

use GuzzleHttp\Client;

$client = new Client([
    'on_stats' => function (\GuzzleHttp\TransferStats $stats) {
        echo $stats->getEffectiveUri() . "\n";
        echo $stats->getTransferTime() . "\n";
        echo $stats->getHandlerStats()['total_time'] . "\n";
    },
]);

$response = $client->request('GET', 'https://example.com/posts/1');

echo $response->getBody();

In this example, we're using the on_stats option to get detailed information about the request. We're printing the
effective URI, transfer time, and total time for the request.

Inside the on_stats callback, you can access the following methods to get insight into the request timings.

getEffectiveUri(): Returns the effective URI of the request.
getTransferTime(): Returns the total time in seconds it took to complete the transfer.
getHandlerStats(): Returns an array of statistics from the handler.

Inside the getHandlerStats() method, you can access the following

total_time: The total time in seconds it took to complete the transfer.
namelookup_time: The time in seconds it took from the start until the name resolving was completed.
connect_time: The time in seconds it took from the start until the TCP connect to the remote host was completed.
appconnect_time: The time in seconds it took from the start until the SSL handshake was completed.
starttransfer_time: The time in seconds it took from the start until the first byte was just about to be transferred.

This is how the app UpChecker tracks performance metrics for each request using Guzzle. You'll get a detailed insight into the request timings and can use this information to optimize your application.

Auto Generate Open Graph Images in NextJS

Paulund — Mon, 20 May 2024 08:12:38 +0000

Next.js has a feature that allows you to generate Open Graph images using code. This feature is useful when you want to generate images for your blog posts, social media posts, or any other content that requires an image.

In a previous article we looked at Adding Metadata to NextJS in this article, we will look at how to generate Open Graph images using code in Next.js.

Install @vercel/og

The first thing you need to do is install the @vercel/og package. This package is a utility for generating Open Graph images. You can install it using npm or yarn.

npm install @vercel/og
# or
yarn add @vercel/og

Generate Images Using Code

Once you have installed the @vercel/og package, you can start generating images using code. The @vercel/og package provides a generate function that you can use to generate images.

Here is an example of how you can generate an Open Graph image using code:

import { generate } from "@vercel/og";

const image = await generate({
  title: "Hello, World!",
  description: "This is an example Open Graph image",
  theme: "light",
  md: true,
  fontSize: 64,
  images: [
    {
      src: "https://example.com/image.jpg",
      width: 800,
      height: 600,
    },
  ],
});

console.log(image);

In this example, we are generating an Open Graph image with the title "Hello, World!" and the description "This is an example Open Graph image". We are using the light theme, rendering the description in markdown, setting the font size to 64, and using an image as the background.

The generate function returns a base64-encoded image that you can use in your application.

Creating A Image Route

To take advantage of this in a Next.js blog you can create a new route that will generate the Open Graph image for a specific blog post. This route will take the blog post content and generate an image that can be used in the Open Graph meta tags.

In this example we're going to use the ImageResponse to generate the image and return it as a response. Create a new file in app/api/og of route.tsx and add the following code:

import { ImageResponse } from 'next/og';

export async function GET() {
  return new ImageResponse(
    (
      <div
        style={{
          fontSize: 40,
          color: 'black',
          background: 'white',
          width: '100%',
          height: '100%',
          padding: '50px 200px',
          textAlign: 'center',
          justifyContent: 'center',
          alignItems: 'center',
        }}
      >
        👋 Hello, World!
      </div>
    ),
    {
      width: 1200,
      height: 630,
    },
  );
}

This code will generate an Open Graph image with the text "👋 Hello, World!" in the center of the image. The image will have a width of 1200 pixels and a height of 630 pixels.

Navigate to http://localhost:3000/api/og/route to see the generated image.

Blog Posts Open Graph Images

You can use this approach to generate the open graph images for your blog posts.

We will do this by passing in a querystring of the blog post title and use this content to generate the image.

import { ImageResponse } from 'next/og'

export async function GET(request: Request) {
    const { searchParams } = new URL(request.url);

    return new ImageResponse(
        (
            // ImageResponse JSX element
            <div
                style={{
                    background: 'black',
                    width: '100%',
                    height: '100%',
                    display: 'flex',
                    flexDirection: 'column',
                    alignItems: 'center',
                    justifyContent: 'center',
                    padding: '0 100px',
                }}
            >
                <h1 style={{fontSize: 64, color: 'white', display: 'block' }}>
                    { searchParams.get('title') }
                </h1>

            </div>
        ),
        {
            width: 1200,
            height: 630,
        }
    )
}

Now you can navigate to http://localhost:3000/api/og/route?title=Hello%20World to see the generated image with the title "Hello World".

Within you generateMetadata function you can now use this route to generate the Open Graph image for your blog post.

    openGraph: {
            title: post.title,
            description: post.description,
            images: [
                {
                    url: `/api/op?title=${post.title}`,
                    width: 1200,
                    height: 630,
                    alt: post.title,
                    type: "image/png",
                }
            ],
            type: "article"
        },
    }

This will generate the Open Graph image for the blog post with the title of the post.

Now when you share the blog post on social media the image will be generated using the content of the blog post.

This is a great way to generate Open Graph images for your blog posts using code in Next.js.

Technical Details

Recommended OG image size: 1200x630 pixels
@vercel/og uses Satori and Resvg to convert HTML and CSS into PNG
@vercel/og API reference

Creating Custom Laravel Collections

Paulund — Fri, 17 May 2024 09:05:18 +0000

Laravel collection are a powerful tool to work with arrays and data. They provide a fluent, convenient way to work with arrays that makes it easy to transform, filter, and manipulate data.

Laravel collections are an extension of the PHP array object, providing additional methods to work with arrays. In this article, we will look at how to create custom collections in Laravel.

When you make a call to the database with eloquent which has more than one result, it will return a collection of models. This collection is an instance of the Illuminate\Support\Collection class. This class provides a lot of useful methods to work with the data.

However, sometimes you may to get data out of these collections in a custom way. For example, if you have a collection of blog posts and want to filter for the published ones you would create a filter like the following.

$publishedPosts = $posts->filter(function ($post) {
    return $post->published;
});

But what if you want to use this filter in multiple places?

You could do something outlined in this article Improving PHP Callbacks where you create an invokable class to encapsulate the filter logic.

class PublishedFilter
{
    public function __invoke($post)
    {
        return $post->published;
    }
}

$publishedPosts = $posts->filter(new PublishedFilter());

This is a good way to encapsulate the filter logic, but it's not very readable. It would be better if you could call the filter method with a more readable name.

$publishedPosts = $posts->published();

This is where custom collections come in. You can create a custom collection class that extends the Laravel collection class and add your custom methods to it.

namespace App\Collections;

use Illuminate\Support\Collection;

class PostCollection extends Collection
{
    public function published()
    {
        return $this->filter(function ($post) {
            return $post->published;
        });
    }
}

Now you can use this custom collection in your models by overriding the newCollection method.

namespace App\Models;

use App\Collections\PostCollection;

class Post extends Model
{
    public function newCollection(array $models = [])
    {
        return new PostCollection($models);
    }
}

Now you can call the published method on your collection of posts.

$publishedPosts = $posts->published();

This is a simple example, but you can create custom collections with any methods you need. This can make your code more readable and maintainable by encapsulating the logic in a single place.