DEV Community: Jeroen van Rensen

How to use the Tailwind JIT compiler

Jeroen van Rensen — Sun, 18 Apr 2021 09:28:35 +0000

Recently, Tailwind v2.1 was released with the JIT compiler included. The JIT (Just In Time) compiler only generates CSS that you actually use, instead of all sorts of classes that you (almost) never use, like subpixel-antialiased, place-self-start, and backdrop-brightness-95. And even better compiling your CSS goes extremely fast, about 100ms.

If you don't know what Tailwind CSS is or how to use it, read my post about it.

The Problem

The main problem with Tailwind CSS was the large development file size. In that file lots of classes are included, most of which you will never use. Because of this, not all spacing variants (like mt-35) are included. Moreover, if you want to use special variants like group-focus and disabled are not included by default.

When going into production, you had to run npm run prod, to purge all unused CSS classes. That means your deployment process takes more time, so users have to wait longer before they can use your website.

The solution

The team behind Tailwind CSS has created the JIT compiler to solve this problem. Once you make a change in one of your files, your CSS gets recompiled with only the classes you actually use.

Compiling CSS has become lots faster. Whereas it used to take a few seconds, now it only takes 100ms, according to the official announcement even 3ms.

How to use it

If you want to use the JIT compiler, follow these steps:

First, install Tailwind v2.1:

npm install -D tailwindcss@latest postcss@latest autoprefixer@latest

Next, add this to your tailwind.config.js file:

// tailwind.config.js

module.exports = {
    mode: 'jit',
    purge: [
        './resources/**/*.blade.php'
    ],
    //
}

Finally, run npm run watch, and keep it running.

Benefits

Using the JIT compiler has more benefits:

Compiling CSS is fast: whereas it used to take a few seconds to compile your CSS, now it gets done within a few milliseconds.
All variants are enabled: you can use variants like focus-group, active and disabled without configuring anything to your configuration file.
Browsers perform better: when you have a very large CSS file, browsers become slow. When using the JIT compiler, only used CSS will be generated, so inspecting HTML/CSS is quicker.
You don't have to worry about purging: sometimes, when you are purging for production, some classes don't get purged, and your design breaks. When using the JIT compiler, purging is done when developing, so you have the same file.

How to unit test Eloquent relationships

Jeroen van Rensen — Sun, 11 Apr 2021 14:18:30 +0000

In my opinion, Eloquent is one of the most powerful features of Laravel. It is an API for interacting with your database, and it has a very nice and easy-to-remember syntax. For example:

$post->author->name;

Will give you the name of the post's author.

This is an example of an Eloquent relationship. Relationships define how your models (tables) are connected. Although most are easy to understand, there are a few more complicated ones.

If you want to learn more about relationships themself, click here and click here for polymorphic relationships.

One to one (has one)

In this example, we have two models: a User and an Address.

A User has one Address
An Address belongs to a User

You can test this relationship from the User model like this:

// tests/Unit/Models/UserTest.php

use App\Models\Address;
use App\Models\User;

/** @test */
public function a_user_has_one_address()
{
    $user = User::factory()->create();
    $address = Address::factory()->create(['user_id' => $user->id]);

    $this->assertInstanceOf(Address::class, $user->address);
    $this->assertEquals($address->id, $user->address_id);
}

One to one inverse (belongs to)

In this example, we have two models: a User and an Address.

A User has one Address
An Address belongs to a User

You can test this relationship from the Address model like this:

// tests/Unit/Models/AddressTest.php

use App\Models\Address;
use App\Models\User;

/** @test */
public function an_address_belongs_to_a_user()
{
    $user = User::factory()->create();
    $address = Address::factory()->create(['user_id' => $user->id]);

    $this->assertEquals($user->id, $address->user_id);
    $this->assertInstanceOf(User::class, $address->user);
    $this->assertEquals($user->id, $address->user->id);
}

One to many (has many)

In this example, we have two models: a Post and a Category.

A Post belongs to a Category
A Category has many Posts

You can test this relationship from the Category model like this:

// tests/Unit/Models/CategoryTest.php

use App\Models\Category;
use App\Models\Post;
use Illuminate\Database\Eloquent\Collection;

/** @test */
public function a_category_has_many_posts()
{
    $category = Category::factory()->create();
    $post = Post::factory()->create(['category_id' => $category->id]);

    $this->assertInstanceOf(Collection::class, $category->posts);
    $this->assertInstanceOf(Post::class, $category->posts->first);
    $this->assertEquals($post->id, $category->posts->first()->id);
}

Has many through

In this example, we have three models: an Author, a Post, and a Language.

A Post belongs to an Author
An Author has many Posts
An Author "belongs" to a Language (speaks a language)
A Language has many Authors

You can test this relationship from the Language model like this:

// tests/Unit/Models/LanguageTest.php

use App\Models\Language;
use App\Models\User;
use App\Models\Post;
use Illuminate\Database\Eloquent\Collection;

/** @test */
public function a_language_has_many_posts()
{
    $language = Language::factory()->create();
    $user = User::factory()->create(['language_id' => $language->id]);
    $post = Post::factory()->create(['user_id' => $user->id]);

    $this->assertInstanceOf(Collection::class, $language->posts);
    $this->assertInstanceOf(Post::class, $language->posts->first);
    $this->assertEquals($post->id, $language->posts->first()->id);
}

Many to many (belongs to many)

In this example, we have two models: a Product and a Tag.

A Product has many Tags
A Tag has many Products

You can test this relationship from the Product model like this:

// tests/Unit/Models/ProductTest.php

use App\Models\Product;
use App\Models\Tag;
use Illuminate\Database\Eloquent\Collection;

/** @test */
public function a_product_has_many_tags()
{
    $product = Product::factory()->create();
    $tag = Tag::factory()->create();
    $product->tags->attach($tag);

    $this->assertInstanceOf(Collection::class, $product->tags);
    $this->assertInstanceOf(Tag::class, $product->tags->first);
    $this->assertEquals($tag->id, $product->tags->first()->id);
}

Polymorphic: one to one

In this example, we have three models: a Post, a Video, and an Image.

A Post has one Image
A Video has one Image
An Image belongs to a Post or a Video

You can test this relationship from the Post (or the Video) model like this:

// tests/Unit/Models/PostTest.php

use App\Models\Post;
use App\Models\Image;

/** @test */
public function a_post_has_one_image()
{
    $post = Post::factory()->create();
    $image = Image::factory()->create([
        'imageable_type' => 'App\Models\Post',
        'imageable_id' => $post->id
    ]);

    $this->assertInstanceOf(Image::class, $post->image);
    $this->assertEquals($image->id, $post->image->id);
}

And you can test this relationship from the Image model like this:

// tests/Unit/Models/ImageTest.php

use App\Models\Image;
use App\Models\Post;
use App\Models\Video;

/** @test */
public function an_image_belongs_to_a_post_or_a_video()
{
    $post = Post::factory()->create();
    $image = Image::factory()->create([
        'imageable_type' => 'App\Models\Post',
        'imageable_id' => $post->id
    ]);

    $this->assertInstanceOf(Post::class, $image->imageable);
    $this->assertEquals($post->id, $image->imageable);

    $video = Video::factory()->create();
    $image = Image::factory()->create([
        'imageable_type' => 'App\Models\Video',
        'imageable_id' => $video->id
    ]);

    $this->assertInstanceOf(Video::class, $image->imageable);
    $this->assertEquals($video->id, $image->imageable);
}

Polymorphic: one to many

In this example, we have three models: a Post, a Video, and a Comment.

A Post has many Comments
A Video has many Comments
A Comment belongs to a Post or a Video

You can test this relationship from the Post (or the Video) model like this:

// tests/Unit/Models/PostTest.php

use App\Models\Comment;
use App\Models\Post;
use Illuminate\Database\Eloquent\Collection;

/** @test */
public function a_post_has_many_comments()
{
    $post = Post::factory()->create();
    $comment = Comment::factory()->create([
        'commentable_type' => 'App\Models\Post',
        'commentable_id' => $post->id
    ]);

    $this->assertInstanceOf(Collection::class, $post->comments);
    $this->assertInstanceOf(Comment::class, $post->comments->first());
    $this->assertEquals($comment->id, $post->comments->first()->id);
}

And you can test this relationship from the Comment model like this:

// tests/Unit/Models/CommentTest.php

use App\Models\Comment;
use App\Models\Post;
use App\Models\Video;
use Illuminate\Database\Eloquent\Collection;

/** @test */
public function a_comment_belongs_to_a_post_or_video()
{
    $post = Post::factory()->create();
    $comment = Comment::factory()->create([
        'commentable_type' => 'App\Models\Post',
        'commentable_id' => $post->id
    ]);

    $this->assertInstanceOf(Post::class, $comment->post);
    $this->assertEquals($post->id, $comment->commentable->id);

    $video = Video::factory()->create();
    $comment = Comment::factory()->create([
        'commentable_type' => 'App\Models\Video',
        'commentable_id' => $video->id
    ]);

    $this->assertInstanceOf(Video::class, $comment->video);
    $this->assertEquals($video->id, $comment->commentable->id);
}

Polymorphic: many to many

In this example, we have three models: a Post, a Video, and a Tag.

A Post has many Tags
A Video has many Tags
A Tag belongs to many Posts or Videos

You can test this relationship from the Post (or the Video) model like this:

// tests/Unit/Models/CommentTest.php

use App\Models\Tag;
use App\Models\Post;
use Illuminate\Database\Eloquent\Collection;

/** @test */
public function a_post_has_many_tags()
{
    $post = Post::factory()->create();
    $tag = Tag::factory()->create();
    $post->tags->attach($tag);

    $this->assertInstanceOf(Collection::class, $post->tags);
    $this->assertInstanceOf(Tag::class, $post->tags->first());
    $this->assertEquals($tag->id, $post->tags->first()->id);
}

And you can test this relationship from the Tag model like this:

// tests/Unit/Models/CommentTest.php

use App\Models\Tag;
use App\Models\Post;
use Illuminate\Database\Eloquent\Collection;

/** @test */
public function a_tag_has_many_posts_and_videos()
{
    $tag = Tag::factory()->create();

    $post = Post::factory()->create();
    $post->tags->attach($tag);

    $this->assertInstanceOf(Collection::class, $tag->posts);
    $this->assertInstanceOf(Post::class, $tag->posts->first());
    $this->assertEquals($post->id, $tag->posts->first()->id);

    $video = Video::factory()->create();
    $video->tags->attach($tag);

    $this->assertInstanceOf(Collection::class, $tag->videos);
    $this->assertInstanceOf(Video::class, $tag->videos->first());
    $this->assertEquals($video->id, $tag->videos->first()->id);
}

Conclusion

Unit testing your Eloquent relationships can be very useful. I hope you learned something from this tutorial. Thanks for reading!

Manual auth in Laravel: email verification

Jeroen van Rensen — Thu, 08 Apr 2021 16:37:55 +0000

With the arrival of Laravel 8, new ways for authentication have been added to the Laravel ecosystem. Fortify, Jetstream and Breeze. Although these tools can save you a lot of time, often when you want something more complex they cost you more time.

Fortunately, Laravel allows you to add manual auth without the use of any package, just Laravel's core. In this series, we're going to learn how to add manual auth in Laravel.

These topics will be covered:

Registering
Signing in and signing out
Password confirmation
Email verification
Password reset

Note: For the examples in this series, I've chosen to use controllers and blade views. But you can also use other technologies, like Livewire or Inertia.js.

Preparation

Before adding the verification functionality, we first have to prepare the User model.

Add MustVerifyEmail in your User model:

// app/Models/User.php

use Illuminate\Contracts\Auth\MustVerifyEmail;
use Illuminate\Foundation\Auth\User as Authenticatable;

class User extends Authenticatable implements MustVerifyEmail
{
    //
}

Next, verify that the Registered event is dispatched after registering:

// app/Http/Controllers/Auth/RegisterController.php

use App\Http\Controllers\Controller;
use Illuminate\Auth\Events\Registered;

class RegisterController extends Controller
{
    public function show()
    {
        //
    }

    public function handle()
    {
        //

        event(new Registered($user));
    }
}

Getting started

Now that we've done the preparation, we can get started.

The email verification feature exists of three parts:

A page to tell the user that they have to verify their email address
A button where a user can click to request another link
A route to verify the email address after clicking on a button in an email

1. A page to tell the user that they have to verify their email address

First, we'll create a controller called Auth\EmailVerificationController:

// app/Http/Controllers/Auth/EmailVerificationController.php

use App\Http\Controllers\Controller;

class EmailVerificationController extends Controller
{
    public function show()
    {
        return view('auth.verify-email');
    }
}

Next, we'll create a view to tell the user that they have to verify their email address. For example:

<!-- resources/views/auth/verify-email.blade.php -->

<h1>Verify email</h1>

<p>Please verify your email address by clicking the link in the mail we just sent you. Thanks!</p>

Finally, we'll add the necessary route:

// routes/web.php

use Illuminate\Support\Facades\Route;

Route::get('/verify-email', [EmailVerificationController::class, 'show'])
    ->middleware('auth')
    ->name('verification.notice'); // <-- don't change the route name

2. A button where a user can click to request another link

In case the user can't find the link anymore, or it has expired, the user should be able to request another link.

First, we'll add the logic in the EmailVerificationController:

// app/Http/Controllers/Auth/EmailVerificationController.php

use App\Http\Controllers\Controller;

class EmailVerificationController extends Controller
{
    public function request()
    {
        auth()->user()->sendEmailVerificationNotification();

        return back()
            ->with('success', 'Verification link sent!');
    }
}

Next, we'll add a form in our view to allow the user to request another link:

<!-- resources/views/auth/verify-email.blade.php -->

<form action="{{ route('verification.request') }}" method="post">
    <button type="submit">Request a new link</button>
</form>

And finally, we'll add the necessary route to make this work:

// routes/web.php

use Illuminate\Support\Facades\Route;

Route::post('/verify-email/request', [EmailVerificationController::class, 'request'])
    ->middleware('auth')
    ->name('verification.request');

3. A route to verify the email address after clicking on a button in an email

The last and most important step is to allow the user to click the link in the email we sent.

As always, we'll first add the controller method:

// app/Http/Controllers/Auth/EmailVerificationController.php

use App\Http\Controllers\Controller;
use Illuminate\Foundation\Auth\EmailVerificationRequest;

class EmailVerificationController extends Controller
{
    public function verify(EmailVerificationRequest $request)
    {
        $request->fulfill();

        return redirect()->to('/home'); // <-- change this to whatever you want
    }
}

Afterward, we'll add the routing:

// routes/web.php

use Illuminate\Support\Facades\Route;

Route::post('/verify-email/{id}/{hash}', [EmailVerificationController::class, 'verify'])
    ->middleware(['auth', 'signed']) // <-- don't remove "signed"
    ->name('verification.verify'); // <-- don't change the route name

Protecting routes

For every route that you want to protect from unverified users, add the verified middleware. For example:

// routes/web.php

use Illuminate\Support\Facades\Route;

Route::post('/posts', [PostController::class, 'create'])
    ->middleware(['auth', 'verified']) // <!-- add the "verified" middleware
    ->name('posts.create');

Conclusion

This is the end of this tutorial. Thanks for reading!

Eloquent polymorphic relationships explained (with examples)

Jeroen van Rensen — Mon, 05 Apr 2021 13:52:37 +0000

In my opinion, Eloquent is one of the most powerful features of Laravel. It is an API for interacting with your database, and it has a very nice and easy-to-remember syntax. For example:

$post->author->name;

Will give you the name of the post's author.

This is an example of an Eloquent relationship. Relationships define how your models (tables) are connected. Although most are easy to understand, there are a few more complicated ones.

In this post, I'm going to show how every relationship works.

One to one

In this example, we have three models: a Post, a Video, and an Image.

A Post has one Image
A Video has one Image
An Image belongs to a Post or Video

And we have this table structure:

posts
    id - integer
    title - string

videos
    id - integer
    name - string

images
    id - integer
    path - string
    imageable_id - integer
    imageable_type - string

We can define these relationships like this:

// app/Models/Post.php

public function image()
{
    return $this->morphOne(Image::class, 'imageable');
}

// app/Models/Video.php

public function image()
{
    return $this->morphOne(Image::class, 'imageable');
}

// app/Models/Image.php

public function imageable()
{
    return $this->morphTo();
}

Now we can access the image like this:

$post->image->path;
$video->image->path;

And if we have the $image, we can get the object where it belongs to (a Post or a Video) like this:

$image->imageable;

One to many

In this example, we have three models: a Post, a Video, and a Comment.

A Post has many Comments
A Video has many Comments
A Comment belongs to a Post or a Video

And we have this table structure:

posts
    id - integer
    title - string

videos
    id - integer
    name - string

comments
    id - integer
    body - string
    commentable_id - integer
    commentable_type - string

We can define the relationships like this:

// app/Models/Post.php

public function comments()
{
    return $this->morphMany(Comment::class, 'commentable');
}

// app/Models/Video.php

public function comments()
{
    return $this->morphMany(Comment::class, 'commentable');
}

// app/Models/Comment.php

public function commentable()
{
    return $this->morphTo();
}

Now we can access the comments like this:

foreach($post->comments as $comment) {
    //
}

foreach($video->comments as $comment) {
    //
}

And if we have a $comment, we can get the corresponding model (a Post or a Video) like this:

$comment->commentable;

Many to many

In this example, we have three models: a Post, a Video, and a Tag.

A Post has many Tags
A Video has many Tags
A Tag belongs to many Posts or Videos

For example, a Tag called "personal" can belong to a `Post and a Video.

We may have this table structure:

`
posts
id - integer
title - string

videos
id - integer
name - string

tags
id - integer
name - string

taggables
tag_id - integer
taggable_id - integer
taggable_type - string
`

We can define the relationships like this:

`php
// app/Models/Post.php

public function tags()
{
return $this->morphToMany(Tag::class, 'taggable');
}
`

`php
// app/Models/Video.php

public function tags()
{
return $this->morphToMany(Tag::class, 'taggable');
}
`

`php
// app/Models/Tag.php

public function posts()
{
return $this->morphedByMany(Post::class, 'taggable');
}

public function videos()
{
return $this->morphedByMany(Video::class, 'taggable');
}
`

Now we can access the tags like this:

`php
foreach($post->tags as $tag) {
//
}

foreach($video->tags as $tag) {
//
}
`

And if we have a $tag, we can access the posts and videos like this:

`php
foreach($tag->posts as $post) {
//
}

foreach($tag->videos as $video) {
//
}
`

Manual auth in Laravel: password confirmation

Jeroen van Rensen — Wed, 31 Mar 2021 19:15:30 +0000

Fortunately, Laravel allows you to add manual auth without the use of any package, just Laravel's core. In this series, we're going to learn how to add manual auth in Laravel.

These topics will be covered:

Registering
Signing in and signing out
Password confirmation
Email verification
Password reset

Note: For the examples in this series, I've chosen to use controllers and blade views. But you can also use other technologies, like Livewire or Inertia.js.

Getting started

First we'll create a controller to load a view:

// app/Http/Controllers/Auth/PasswordConfirmationController.php

namespace App\Http\Controllers\Auth;

use App\Http\Controllers\Controller;

class PasswordConfirmationController extends Controller
{
    public function show()
    {
        return view('auth.confirm-password');
    }

    public function handle()
    {
        // Handling the response
    }
}

Routing

Next, we'll add routes:

// routes/web.php

use App\Http\Controllers\Auth\PasswordConfirmationController;
use Illuminate\Support\Facades\Route;

Route::get('/confirm-password', [PasswordConfirmationController::class, 'show'])
    ->middleware('auth')
    ->name('password.confirm');

Route::post('/confirm-password', [PasswordConfirmationController::class, 'handle'])
    ->middleware('auth')
    ->name('password.confirm');

Views

After routing, we create a form for the user to fill in their password. For example:

<!-- resources/views/auth/confirm-password.blade.php -->

<h1>Confirm Password</h1>

<form  action="{{ route('password.confirm') }}" method="post">
    @csrf

    <!-- Password -->
    <label for="password">Password</label>
    <input type="password" name="password" id="password"  />

    <!-- Submit button -->
    <button type="submit">Confirm Password</button>
</form>

Controller logic

Finally, we'll add some code to the handle method:

First, we check if the password is correct:

// app/Http/Controllers/Auth/PasswordConfirmationController.php

use Illuminate\Support\Facades\Hash;

if (!Hash::check(request()->password, auth()->user()->password)) {
    return back()->withErrors(['password' => 'The provided password does not match our records.']);
}

If the password was correct, we will tell Laravel that the password was correct.

// app/Http/Controllers/Auth/PasswordConfirmationController.php

session()->passwordConfirmed();

Finally, we will redirect the user as intented after a success.

// app/Http/Controllers/Auth/PasswordConfirmationController.php

return redirect()->intended();

Conclusion

Where as registering and signing in and out does not use much of Laravel's authentication features, confirming a password does. However, you still have a lot of freedom as to how you want to implement it.

If you at some point couldn't follow the tutorial anymore, this is the finished Auth\PasswordConfirmationController:

<?php

// app/Http/Controller/Auth/PasswordConfirmationController.php

namespace App\Http\Controllers\Auth;

use App\Http\Controllers\Controller;
use Illuminate\Support\Facades\Hash;

class PasswordConfirmationController extends Controller
{
    public function show()
    {
        return view('auth.confirm-password');
    }

    public function handle()
    {
        if (!Hash::check(request()->password, auth()->user()->password)) {
            return back()->withErrors(['password' => 'The provided password does not match our records.']);
        }

        session()->passwordConfirmed();

        return redirect()->intended();
    }
}

Eloquent relationships explained (with examples)

Jeroen van Rensen — Sun, 28 Mar 2021 09:14:27 +0000

In my opinion, Eloquent is one of the most powerful features of Laravel. It is an API for interacting with your database, and it has a very nice and easy-to-remember syntax. For example:

$post->author->name;

Will give you the name of the post's author.

This is an example of an Eloquent relationship. Relationships define how your models (tables) are connected. Although most are easy to understand, there are a few more complicated ones.

In this post, I'm going to show how every relationship works.

One to one (has one)

For this example, we have two models: a User and an Address. The User model holds information such as name, email address, and password, and the Address model holds information like country, state, city, etc.

A User has one Address
An Address belongs to a User

We may have this table structure:

users
    id - integer
    name - string
    email - string
    password - string

address
    id - integer
    country - string
    city - string
    user_id - integer

You can define these relationships like this:

// app/Models/User.php

public function address()
{
    return $this->hasOne(Address::class);
}

Now you can access the user's address using $user->address->city.

Note: for this to work, the Address model should have a user_id column.

Inverse (belongs to)

If you have an Address and want to find the corresponding User, then define this relationship:

// app/Models/Address.php

public function user()
{
    return $this->belongsTo(User::class);
}

One to many (has many)

In this example, we have two models: a Post and a Category.

A Post belongs to a Category
A Category has many Posts

And we have this table structure:

categories
    id - integer
    name - string

posts
    id - integer
    title - string
    category_id - integer

We can define this relationship like this:

// app/Models/Category.php

public function posts()
{
    return $this->hasMany(Post::class);
}

And you can access all the posts like this:

foreach($category->posts as $post) {
    //
}

Note: for this to work, the Post model should have a category_id column.

Many to one (belongs to)

In this example, we have two models: a Post and a Category.

A Post belongs to a Category
A Category has many Posts

And we have this table structure:

categories
    id - integer
    name - string

posts
    id - integer
    title - string
    category_id - integer

We can define this relationship like this:

// app/Models/Post.php

public function category()
{
    return $this->belongsTo(Category::class);
}

And you can access the Post's category like this:

$post->category->name;

Has many through

This relationship is a bit more difficult. In this example, we have three models: an Author, a Post, and a Language.

A Post belongs to an Author
An Author has many Posts
An Author "belongs" to a Language (speaks a language)
A Language has many Authors

For example, this is our table structure:

languages
    id - integer
    name - string

authors
    id - integer
    name - string
    language_id - integer

posts
    id - integer
    title - string
    author_id - integer

If we want to get all posts in a specific language, we can define this relationship:

// app/Models/Language.php

public function posts()
{
    return $this->hasManyThrough(Post::class, User::class);
}

Now, we can get all posts using:

foreach($language->posts as $post) {
    //
}

Inverse

If you now want to get the Language of a Post, you can just simply do this:

$post->user->language->name;

Many to many (belongs to many)

In this example, we have two models: a Product and a Tag.

A Product has many Tags
A Tag has many Products

And we may have this table structure:

products
    id - integer
    name - string
    price - integer

tags
    id - integer
    name - string

product_tag
    product_id - integer
    tag_id - integer

Note: in the table structure, we have a third table, product_tag. This table connects products to tags.

Now we can define the relationships like this:

// app/Models/Product.php

public function tags()
{
    return $this->belongsToMany(Tag::class);
}

// app/Models/Tag.php

public function products()
{
    return $this->belongsToMany(Product::class);
}

Now we can get all tags/products using:

foreach($product->tags as $tag) {
    //
}

foreach($tag->products as $product) {
    //
}

In the next post, I'm going to show what polymorphic relationships are and how to use them. Thanks for reading!

Nested comments in Laravel

Jeroen van Rensen — Mon, 22 Mar 2021 20:08:30 +0000

Last week I added a nested comments feature to my blog. You can see it at the bottom of this post, where I received a few comments. In this post, I would like to tell you how I added this feature.

Note: This is not a step-by-step tutorial. Rather, I'll explain some things that I think are interesting.

Migrations

First of all, I added a parent_id column in my comments migration.

$table->integer('parent_id')->nullable();

If it is null, it is a root comment and else it is nested.

Leaving comments

Next, I updated my Livewire component to allow for replies, but only on root comments. When someone clicks "reply", a parent property at the component will be set to that comment and it shows a little message like "In reply to: Jeroen".

When a user hits "save", a little check is done to see if the comment really belongs to the current post and if it is a root comment, because I only want to allow comments to be nested one level deep.

Showing comments

When showing comments, all root comments (with an empty parent_id) will be listed, and for each comment, all children will be listed as well. These are exactly the same, except the children are a little bit indented at the left and don't have a "reply" button.

Notifications

When someone replies to a comment, everyone who also replied to that comment will get notified, but participants on other comments won't.

Before this, everyone would get notified. But that's sometimes weird if there are two discussions below one post.

Conclusion

Thanks for reading! I hope you learned something. At least it was a joy to write.

Manual auth in Laravel: signing in and out

Jeroen van Rensen — Thu, 18 Mar 2021 16:55:18 +0000

This post was published first at my website. Please check it for updates.

Fortunately, Laravel allows you to add manual auth without the use of any package, just Laravel's core. In this series, we're going to learn how to add manual auth in Laravel.

These topics will be covered:

Registering
Signing in and signing out
Password confirmation
Email verification
Password reset

Note: For the examples in this series, I've chosen to use controllers and blade views. But you can also use other technologies, like Livewire or Inertia.js.

Signing in

For this tutorial, we'll create an Auth\LoginController for the login functionality.

// app/Http/Controllers/Auth/LoginController.php

use App\Http\Controllers\Controller;

class LoginController extends Controller
{
    public function show()
    {
        return view('auth.login');
    }

    public function handle()
    {
        // Signing in...
    }
}

Now we'll use the Auth facade to try to sign in the user:

// app/Http/Controllers/Auth/LoginController.php

$success = auth()->attempt([
    'email' => request('email'),
    'password' => request('password')
], request()->has('remember'));

Note: after calling auth()->attempt() the user is automatically signed in.

In this case, I assume you have a "remember me" checkbox. If that is checked, it will be in the request, and if not it won't. You can also hardcode true or false if you don't have such a checkbox.

Next, you probably want to redirect the users after a successful login and show errors if it failed.

// app/Http/Controllers/Auth/LoginController.php

use App\Providers\RouteServiceProvider;

if($success) {
    return redirect()->to(RouteServiceProvider::HOME);
}

return back()->withErrors([
    'email' => 'The provided credentials do not match our records.',
]);

Views

Next, create an auth.login view and add a form, for example:

<!-- resources/views/auth/login.blade.php -->

<h1>Login</h1>

<form  action="{{ route('login') }}"  method="post">
    @csrf

    <!-- Email-->
    <label for="email">Email</label>
    <input type="email" name="email" id="email"  />

    <!-- Password -->
    <label for="password">Password</label>
    <input type="password" name="password" id="password"  />

    <!-- Submit button -->
    <button type="submit">Login</button>
</form>

Routing

The last step is to add login routes:

// routes/web.php

use App\Http\Controllers\Auth\LoginController;
use Illuminate\Support\Facades\Route;

Route::get('/login', [LoginController::class, 'show'])
    ->name('login');

Route::post('/login', [LoginController::class, 'handle'])
    ->name('login');

And now you're done! Users can now login!

Finished controller

If something went too quickly, here is the full finished LoginController:

<?php

// app/Http/Controllers/Auth/LoginController.php

namespace App\Http\Controllers\Auth\LoginController;

use App\Http\Controllers\Controller;
use App\Providers\RouteServiceProvider;

class LoginController extends Controller
{
    public function show()
    {
        return view('auth.login');
    }

    public function handle()
    {
        $success = auth()->attempt([
            'email' => request('email'),
            'password' => request('password')
        ], request()->has('remember'));

        if($success) {
            return redirect()->to(RouteServiceProvider::HOME);
        }

        return back()->withErrors([
            'email' => 'The provided credentials do not match our records.',
        ]);
    }
}

Signing out

Signing out is really simple:

auth()->logout();

If you want it in a controller, you can use one similar to this one:

<?php

// app/Http/Controllers/Auth/LogoutController.php

namespace App\Http\Controllers\Auth\LogoutController;

use App\Http\Controllers\Controller;

class LogoutController extends Controller
{
    public function handle()
    {
        auth()->logout();

        return redirect()->route('login');
    }
}

Routing

Next, add the route:

// routes/web.php

use App\Http\Controllers\Auth\LogoutController;
use Illuminate\Support\Facades\Route;

Route::post('/logout', [LogoutController::class, 'handle'])
    ->name('logout');

Views

And finally, add this in your view:

<!-- resources/views/layouts/app.blade.php -->

<form action="{{ route('logout') }}" method="post">
    @csrf

    <button type="submit">Logout</button>
</form>

Conclusion

Signing in and out in Laravel is really simple. The next time we are going to take a look at password confirmation. Please subscribe to my newsletter to get updated when a new post is published.

Manual auth in Laravel: registering

Jeroen van Rensen — Sun, 14 Mar 2021 09:36:19 +0000

This post was published first on my website. Please check it for updates.

Fortunately, Laravel allows you to add manual auth without the use of any package, just Laravel's core. In this series, we're going to learn how to add manual auth in Laravel.

These topics will be covered:

Registering
Signing in
Signing out
Password confirmation
Email verification
Password reset

Note: For the examples in this series, I've chosen to use controllers and blade views. But you can also use other technologies, like Livewire or Inertia.js.

Getting started

Registering a new user is by far the easiest of all authentication features in Laravel. You just create a new User model.

// app/Http/Controllers/Auth/RegisterController.php

use App\Http\Controllers\Controller;
use App\Models\User;
use  Illuminate\Support\Facades\Hash;

class RegisterController extends Controller
{
    public function show()
    {
        return view('auth.register');
    }

    public function handle()
    {
        $user = User::create([
            'name' => request('name'),
            'email' => request('email'),
            'password' => Hash::make(request('password'))
        ]);
    }
}

Be sure to hash the password before storing it in the database.

Validating

Next, we'll add some validation.

// app/Http/Controllers/Auth/RegisterController.php

request()->validate([
    'name' => ['required', 'string', 'max:255'],
    'email' => ['required', 'email', 'max:255'],
    'password' => ['required', 'string', 'min:8', 'confirmed']
]);

We use the confirmed validation rule to ensure that the user has confirmed the password. This rule fails when there is no password_confirmation in the request, so be sure to add it to your form.

Events

When registering, dispatch the Registered event so that the user will get an email verification link sent to them.

// app/Http/Controllers/Auth/RegisterController.php

use Illuminate\Auth\Events\Registered;

event(new Registered($user));

Signing in

When using a Laravel package for authentication, the user is signed in after registering. It provides a better user experience because they don't have to login directly after registering.

// app/Http/Controllers/Auth/RegisterController.php

use Illuminate\Support\Facades\Auth;

Auth::login($user);

Redirecting

Of course, after a new user is created, you want to redirect them to a welcome or dashboard page. Add this at the end of the handle method:

// app/Http/Controllers/Auth/RegisterController.php

use App\Providers\RouteServiceProvider;

return redirect()->to(RouteServiceProvider::HOME);

Routing

Now that our register feature is done, we'll register the needed routes.

// routes/web.php

use App\Http\Controllers\Auth\RegisterController;
use Illuminate\Support\Facades\Route;

Route::get('/register', [RegisterController::class, 'show'])->name('register');
Route::post('/register', [RegisterController::class, 'handle'])->name('register');

Views

Finally, create an auth.register view with a form. For example:

<!-- resources/views/auth/register.blade.php -->

<h1>Register</h1>

<form  action="{{ route('register') }}"  method="post">
    <!-- Name -->
    <label for="name">Name</label>
    <input type="text" name="name" id="name"  />

    <!-- Email-->
    <label for="email">Email</label>
    <input type="email" name="email" id="email"  />

    <!-- Password -->
    <label for="password">Password</label>
    <input type="password" name="password" id="password"  />

    <!-- Confirm password -->
    <label for="password_confirmation">Confirm password</label>
    <input type="password" name="password_confirmation"  id="password_confirmation" />

    <!-- Submit button -->
    <button type="submit">Register</button>
</form>

Conclusion

Registering in Laravel is one of the easiest features. If you at some point didn't follow the tutorial, here's the completed RegisterController:

<?php

// app/Http/Controller/Auth/RegisterController.php

namespace App\Http\Controllers\Auth;

use App\Http\Controllers\Controller;
use App\Models\User;
use App\Providers\RouteServiceProvider;
use Illuminate\Auth\Events\Registered;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Hash;

class RegisterController extends Controller
{
    public function show()
    {
        return  view('auth.register');
    }

    public function handle()
    {
        request()->validate([
            'name' => ['required', 'string', 'max:255'],
            'email' => ['required', 'email', 'max:255'],
            'password' => ['required', 'string', 'min:8', 'confirmed']
        ]);

        $user = User::create([
            'name' => request('name'),
            'email' => request('email'),
            'password' => Hash::make(request('password'))
        ]);

        event(new Registered($user));

        Auth::login($user);

        return redirect()->to(RouteServiceProvider::HOME);
    }
}

How to use UUIDs in URLs in Laravel

Jeroen van Rensen — Wed, 10 Mar 2021 12:15:14 +0000

This post was published first on my website. Please check it for updates.

In my previous post, I told why you shouldn't expose your default incrementing IDs, because of security and other issues. Luckily there are some solutions for this problem: slugs and UUIDs.

If you want to read more about slugs, you can read more about it here.

In this post, I'm going to show you how you can configure UUIDs with Laravel. Then you'll get URLs like these:

http://www.example.org/orders/065e9fb3-6bec-494c-9917-4ab8e71750d4
http://www.example.org/users/d3835dda-e08f-4ed5-baff-756d62a749b2
http://www.example.org/images/avatar-d54a923b-c5d4-4294-8033-a221a57ef361.jpg

Migrations

First, we'll have to add a uuid column in the migration. Laravel has a UUID column available that we can use.

// database/migrations/create_posts_table.php

Schema::create('posts',  function  (Blueprint  $table)  {
    $table->id();
    $table->uuid('uuid')->unique(); // <!-- Add the UUID column in your migration
    $table->string('title');
    $table->text('body');
    $table->timestamps();
});

Models

Next, every time a model (for example a post) is created, we want to automatically assign a UUID to it. We can do that in the boot model of our model.

// app/Models/Post.php

use Illuminate\Support\Str;

protected  static  function  boot()
{
    parent::boot();

    static::creating(function  ($model)  {
        $model->uuid = (string) Str::uuid();
    });
}

Factories

If you are using model factories to quickly create test models, you don't have to add anything to them because the boot method will run when using factories too.

Routing

The last step is to update the routes file. Every time you use Route Model Binding in your routes/web.php file add :uuid at the end:

// routes/web.php

Route::get('/posts/{post:uuid}', [PostController::class, 'show'])
    ->name('posts.show');

Now Laravel will automatically use the UUID column for routing.

URLs

If you use URLs, you'll have to update your routes everywhere. For example:

// resources/views/posts/index.blade.php

<ul>
    @foreach($posts as $post)
        <li>
            <a href="{{ url('/posts/' . $post->uuid) }}">
                {{ $post->title }}
            </a>
        </li>
    @endforeach
</ul>

`route` helper

If you're using the route helper method, you don't have to change anything! For example:

// resources/views/posts/index.blade.php

<ul>
    @foreach($posts as $post)
        <li>
            <a href="{{ route('posts.show', $post) }}">
                {{ $post->title }}
            </a>
        </li>
    @endforeach
</ul>

Conclusion

As you can see, using Laravel it's very easy to use UUIDs and hide your incrementing IDs. I hope you liked this post, and if you did, you can subscribe to my newsletter below.

Why you shouldn't expose your incrementing IDs

Jeroen van Rensen — Sun, 07 Mar 2021 17:25:38 +0000

This post was published first at my website. Please check it for updates.

By default, every Laravel model has an incrementing ID. Although this makes things very easy, there are some security reasons why you shouldn't be exposing this ID to your users. In this article, I'm going to explain why.

Security risk

If you use default incrementing IDs in your URLs, anyone can guess which one is the previous, and which one is the next. For example, you've got orders and you use this URL scheme:

http://www.example.org/orders/9

Anyone can know that the previous was 8 and the next will be 10. Of course, you don't want your users to know what others bought.

Although you should return a 403 error if an unauthorized user tries to visit http://www.example.org/orders/8, if you forget to do so you have a big security risk.

Resource harvesting

If you have images and corresponding records in your DB, you can have image names like those:

http://example.org/images/avatar34.jpg
http://example.org/images/avatar35.jpg

And anyone can visit http://example.org/images/avatar33.jpg and so on to get all your images. This practice is called resource harvesting and applies to models too but is a bigger problem with static files.

Others know how big your website is

If someone registers and visits their account page, they may end up with a URL like this one:

http://example.org/users/223

Now they know they are number 223. This may not seem like an issue at first, but your competition can create an account too and see how many users you have.

Of course, if you create a forum thread or something else with the same URL scheme, you have this problem too. For example:

http://example.org/threads/43
http://example.org/books/some-book/reviews/34

Solutions

Fortunately, there are plenty of solutions available for this problem. I've described two.

Slugs

You may use slugs to have a unique identifier that exposes nothing about your DB size.

A post about a specific subject
a-post-about-a-specific-subject

And it is what I do with my blog too. But for some models, a slug doesn't make much sense, such as for users or reviews.

And besides, it's a lot of work to get slugs working, especially if everyone can create a new model. For example:

What if two slugs are the same?
What if a title changes?

UUIDs

A UUID (Universally Unique Identifier) is kind of a normal ID, except no-one knows what the previous or next one is.

This is an example of a UUID:

e4a3e607-24b0-40e0-b56d-882304123506

And you'll get URLs like this one:

http://www.example.org/orders/065e9fb3-6bec-494c-9917-4ab8e71750d4
http://www.example.org/users/d3835dda-e08f-4ed5-baff-756d62a749b2
http://www.example.org/images/avatar-d54a923b-c5d4-4294-8033-a221a57ef361.jpg

If you would like to learn more about UUIDs, I've written a tutorial about how to use UUIDs in your URLs with Laravel.

How to send free emails using Sendinblue

Jeroen van Rensen — Mon, 01 Mar 2021 19:41:52 +0000

This post was originally published on my blog.

Many web applications send emails, for example when someone is registered you want to send them a welcome email. Although you can do it for free using the Gmail SMTP server, it is more solid to use a service like Sendinblue.

Besides, using Sendinblue you can send 300 emails/day, and using Gmail you're limited to only 100 emails/day. Unfortunately, I couldn't find good documentation on how to use Sendinblue with Laravel, but I finally got it working so that's why I'm sharing it with you.

Create a Sendinblue email account

Head over to Sendinblue and create an account. Next, go to your account section and in the left sidebar click SMTP & API. Afterwards click at the SMTP tab and finally copy your secret SMTP key value.

Configuring Laravel

After you grabbed your secret key, go to your .env file in your Laravel application. Next, add these values:

MAIL_MAILER=smtp
MAIL_HOST=smtp-relay.sendinblue.com
MAIL_PORT=587
MAIL_USERNAME=john@gmail.com
MAIL_PASSWORD=VAO929swI6sRIoaI
MAIL_ENCRYPTION=tls
MAIL_FROM_ADDRESS=john@gmail.com
MAIL_FROM_NAME="${APP_NAME}"

Be sure to add the email from your Sendinblue account in the MAIL_USERNAME and MAIL_FROM_ADDRESS sections, and your secret SMTP key in the MAIL_PASSWORD section.

That's it! Using Sendinblue you're limited to 300 emails/day on the free plan, and that's more than every other mailing service. If you need to send more emails, their plans start at €19/month or $25/month for 10 000 emails/month.

DEV Community: Jeroen van Rensen

How to use the Tailwind JIT compiler

The Problem

The solution

How to use it

Benefits

How to unit test Eloquent relationships

One to one (has one)

One to one inverse (belongs to)

One to many (has many)

Has many through

Many to many (belongs to many)

Polymorphic: one to one

Polymorphic: one to many

Polymorphic: many to many

Conclusion

Manual auth in Laravel: email verification

Preparation

Getting started

1. A page to tell the user that they have to verify their email address

2. A button where a user can click to request another link

3. A route to verify the email address after clicking on a button in an email

Protecting routes

Conclusion

Eloquent polymorphic relationships explained (with examples)

One to one

One to many

Many to many

Manual auth in Laravel: password confirmation

Getting started

Routing

Views

Controller logic

Conclusion

Eloquent relationships explained (with examples)

One to one (has one)

Inverse (belongs to)

One to many (has many)

Many to one (belongs to)

Has many through

Inverse

Many to many (belongs to many)

Nested comments in Laravel

Migrations

Leaving comments

Showing comments

Notifications

Conclusion

Manual auth in Laravel: signing in and out

Signing in

Views

Routing

Finished controller

Signing out

Routing

Views

Conclusion

Manual auth in Laravel: registering

Getting started

Validating

Events

Signing in

Redirecting

Routing

Views

Conclusion

How to use UUIDs in URLs in Laravel

Migrations

Models

Factories

Routing

URLs

route helper

Conclusion

Why you shouldn't expose your incrementing IDs

Security risk

Resource harvesting

Others know how big your website is

Solutions

Slugs

`route` helper