DEV Community: M H Hasib

Laravel Passport: API authentication with access and refresh token

M H Hasib — Wed, 22 May 2024 10:24:03 +0000

In Laravel, we can use authentication systems like Sanctum, and Passport. Still, Passport is one of the most popular authentication systems in Laravel. Most of the developer like to do authentication using Laravel Passport because of its extraordinary features. Like if you want to authenticate machine to machine, Passport is one of the favorite tools to use. So without a further delay, let's jump into code.

In this tutorial, we are using the latest version of Laravel which is Laravel 11.

First of all, let's create a project in Laravel using the following command.

composer create-project laravel/laravel passport-authentication

So, we created a brand new Laravel project. Now if you go to the route directory will not find any api.php file. Because, from Laravel 11 API will not come by default. If we want API we need to install it manually. Before setting up Laravel Passport, make sure you set up your .env file with your database and other credentials. Now migrate the database using the following command.

php artisan migrate

Now let's install Laravel Passport using the following command.

php artisan install:api --passport

So we have installed Laravel Passport successfully. Now we have to set up the model you want to connect for authentication. Let's prepare our model. I am using the User model for the authentication.

We have to use the HasApiTokens trait in the user model. Also, need to import the namespace Laravel\Passport\HasApiTokens at the top. So here is our User model.

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Foundation\Auth\User as Authenticatable;
use Illuminate\Notifications\Notifiable;
use Laravel\Passport\HasApiTokens;

class User extends Authenticatable
{
    use HasApiTokens, HasFactory, Notifiable;
}

Now go to the config/auth.php file and you will find the guard array like this.

'guards' => [
        'web' => [
            'driver' => 'session',
            'provider' => 'users',
        ],
    ],

Now we have to modify it and need to add another guard in the array named api whose driver should be passport and whose provider should be users as we are using users as our authentication table. Now the guards array should look like this.

'guards' => [
    'web' => [
        'driver' => 'session',
        'provider' => 'users',
    ],

    'api' => [
        'driver' => 'passport',
        'provider' => 'users',
    ],
],

Now When deploying Passport to your application's servers for the first time, you will likely need to run the passport:keys command. This command generates the encryption keys Passport needs in order to generate access tokens. The generated keys are not typically kept in source control:

php artisan passport:keys

Now, open AppServiceProvider and add this code Passport::enablePasswordGrant(); to the boot method. And your AppServiceProvider should look like this.

<?php

namespace App\Providers;

use Illuminate\Support\ServiceProvider;
use Laravel\Passport\Passport;

class AppServiceProvider extends ServiceProvider
{
    /**
     * Register any application services.
     */
    public function register(): void
    {
        //
    }

    /**
     * Bootstrap any application services.
     */
    public function boot(): void
    {
        Passport::enablePasswordGrant();
    }
}

Now we need to create password grant client using this command

php artisan passport:client --password

It will generate a password secret id and a secret key. You need to add these code in your .env file like this.

APP_NAME=Laravel
APP_ENV=local
APP_KEY=base64:tq7VnODMFUn5CLAaaiXEy338CS9LxSr4RxPrvC+q1WA=
APP_DEBUG=true
APP_TIMEZONE=UTC
APP_URL=http://passport-authentication.test

APP_LOCALE=en
APP_FALLBACK_LOCALE=en
APP_FAKER_LOCALE=en_US

APP_MAINTENANCE_DRIVER=file
APP_MAINTENANCE_STORE=database

BCRYPT_ROUNDS=12

LOG_CHANNEL=stack
LOG_STACK=single
LOG_DEPRECATIONS_CHANNEL=null
LOG_LEVEL=debug

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=passport_authentication
DB_USERNAME=root
DB_PASSWORD=

SESSION_DRIVER=database
SESSION_LIFETIME=120
SESSION_ENCRYPT=false
SESSION_PATH=/
SESSION_DOMAIN=null

BROADCAST_CONNECTION=log
FILESYSTEM_DISK=local
QUEUE_CONNECTION=database

CACHE_STORE=database
CACHE_PREFIX=

MEMCACHED_HOST=127.0.0.1

REDIS_CLIENT=phpredis
REDIS_HOST=127.0.0.1
REDIS_PASSWORD=null
REDIS_PORT=6379

MAIL_MAILER=log
MAIL_HOST=127.0.0.1
MAIL_PORT=2525
MAIL_USERNAME=null
MAIL_PASSWORD=null
MAIL_ENCRYPTION=null
MAIL_FROM_ADDRESS="hello@example.com"
MAIL_FROM_NAME="${APP_NAME}"

AWS_ACCESS_KEY_ID=
AWS_SECRET_ACCESS_KEY=
AWS_DEFAULT_REGION=us-east-1
AWS_BUCKET=
AWS_USE_PATH_STYLE_ENDPOINT=false

VITE_APP_NAME="${APP_NAME}"


PASSPORT_PASSWORD_CLIENT_ID=9c1a21e3-307b-473e-a325-bd14ac0fdbc2
PASSPORT_PASSWORD_SECRET=VuFvz2GNiwJrRQMyF9FZLg9r4vb0zYXwhQMYH4NJ

Look at the bottom of this .env file. I have added two variables named PASSPORT_PASSWORD_CLIENT_ID and PASSPORT_PASSWORD_SECRET.

Now, we are ready to create our route and controller code. Now go to the routes/api.php and create these routes. Here our routes should look like this.

<?php

use Illuminate\Http\Request;
use Illuminate\Support\Facades\Route;
use App\Http\Controllers\Api\AuthController;

Route::post('/login', [AuthController::class, 'login']);
Route::post('/register', [AuthController::class, 'register']);
Route::post('/refresh', [AuthController::class, 'refreshToken']);

Route::group(['middleware' => ['auth:api']], function () {
    Route::get('/me', [AuthController::class, 'me']);
    Route::post('/logout', [AuthController::class, 'logout']);

});

Now create a controller in Api folder using following this command.

php artisan make:controller Api/AuthController

Now open the AuthController.php and replace this code in this code.

<?php

namespace App\Http\Controllers\Api;

use App\Http\Controllers\Controller;
use App\Http\Requests\LoginRequest;
use App\Http\Requests\RefreshTokenRequest;
use App\Http\Requests\RegisterRequest;
use App\Models\User;
use Illuminate\Http\JsonResponse;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Http;

class AuthController extends Controller
{
    /**
     * User registration
     */
    public function register(RegisterRequest $request): JsonResponse
    {
        $userData = $request->validated();

        $userData['email_verified_at'] = now();
        $user = User::create($userData);

        $response = Http::post(env('APP_URL') . '/oauth/token', [
            'grant_type' => 'password',
            'client_id' => env('PASSPORT_PASSWORD_CLIENT_ID'),
            'client_secret' => env('PASSPORT_PASSWORD_SECRET'),
            'username' => $userData['email'],
            'password' => $userData['password'],
            'scope' => '',
        ]);

        $user['token'] = $response->json();

        return response()->json([
            'success' => true,
            'statusCode' => 201,
            'message' => 'User has been registered successfully.',
            'data' => $user,
        ], 201);
    }

    /**
     * Login user
     */
    public function login(LoginRequest $request): JsonResponse
    {
        if (Auth::attempt(['email' => $request->email, 'password' => $request->password])) {
            $user = Auth::user();

            $response = Http::post(env('APP_URL') . '/oauth/token', [
                'grant_type' => 'password',
                'client_id' => env('PASSPORT_PASSWORD_CLIENT_ID'),
                'client_secret' => env('PASSPORT_PASSWORD_SECRET'),
                'username' => $request->email,
                'password' => $request->password,
                'scope' => '',
            ]);

            $user['token'] = $response->json();

            return response()->json([
                'success' => true,
                'statusCode' => 200,
                'message' => 'User has been logged successfully.',
                'data' => $user,
            ], 200);
        } else {
            return response()->json([
                'success' => true,
                'statusCode' => 401,
                'message' => 'Unauthorized.',
                'errors' => 'Unauthorized',
            ], 401);
        }

    }

    /**
     * Login user
     *
     * @param  LoginRequest  $request
     */
    public function me(): JsonResponse
    {

        $user = auth()->user();

        return response()->json([
            'success' => true,
            'statusCode' => 200,
            'message' => 'Authenticated use info.',
            'data' => $user,
        ], 200);
    }

    /**
     * refresh token
     *
     * @return void
     */
    public function refreshToken(RefreshTokenRequest $request): JsonResponse
    {
        $response = Http::asForm()->post(env('APP_URL') . '/oauth/token', [
            'grant_type' => 'refresh_token',
            'refresh_token' => $request->refresh_token,
            'client_id' => env('PASSPORT_PASSWORD_CLIENT_ID'),
            'client_secret' => env('PASSPORT_PASSWORD_SECRET'),
            'scope' => '',
        ]);

        return response()->json([
            'success' => true,
            'statusCode' => 200,
            'message' => 'Refreshed token.',
            'data' => $response->json(),
        ], 200);
    }

    /**
     * Logout
     */
    public function logout(): JsonResponse
    {
        Auth::user()->tokens()->delete();

        return response()->json([
            'success' => true,
            'statusCode' => 204,
            'message' => 'Logged out successfully.',
        ], 204);
    }
}

Now, create three request file step by step.

RegisterRequest:

 php artisan make:request RegisterRequest

Now replace this code in this file.

<?php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class RegisterRequest extends FormRequest
{
    /**
     * Determine if the user is authorized to make this request.
     */
    public function authorize(): bool
    {
        return true;
    }

    /**
     * Get the validation rules that apply to the request.
     *
     * @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
     */
    public function rules(): array
    {
        return [
            'name' => ['required', 'max:255'],
            'email' => ['required', 'email', 'unique:users'],
            'password' => ['required', 'min:8', 'confirmed'],
        ];
    }
}

LoginRequest:

 php artisan make:request LoginRequest

Now replace this code in this file.

<?php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class LoginRequest extends FormRequest
{
    /**
     * Determine if the user is authorized to make this request.
     */
    public function authorize(): bool
    {
        return true;
    }

    /**
     * Get the validation rules that apply to the request.
     *
     * @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
     */
    public function rules(): array
    {
        return [
            'email' => 'email|required',
            'password' => 'required',
        ];
    }
}

RefreshTokenRequest:

 php artisan make:request RefreshTokenRequest

Now replace this code in this file.

<?php

namespace App\Http\Requests;

use Illuminate\Foundation\Http\FormRequest;

class RefreshTokenRequest extends FormRequest
{
    /**
     * Determine if the user is authorized to make this request.
     */
    public function authorize(): bool
    {
        return true;
    }

    /**
     * Get the validation rules that apply to the request.
     *
     * @return array<string, \Illuminate\Contracts\Validation\ValidationRule|array<mixed>|string>
     */
    public function rules(): array
    {
        return [
            'refresh_token' => ['required', 'string'],
        ];
    }
}

One more suggestion:

Sometimes you might need to change the refresh token and access token validity. For these changes you can add the following code in the boot method of AppServiceProvider.

Passport::tokensExpireIn(now()->addDays(15));
Passport::refreshTokensExpireIn(now()->addDays(30));
Passport::personalAccessTokensExpireIn(now()->addMonths(6));

Then your AppServiceProvider should look like this.

<?php

namespace App\Providers;

use Illuminate\Support\ServiceProvider;
use Laravel\Passport\Passport;

class AppServiceProvider extends ServiceProvider
{
    /**
     * Register any application services.
     */
    public function register(): void
    {
        //
    }

    /**
     * Bootstrap any application services.
     */
    public function boot(): void
    {
        Passport::tokensExpireIn(now()->addDays(15));
        Passport::refreshTokensExpireIn(now()->addDays(30));
        Passport::personalAccessTokensExpireIn(now()->addMonths(6));
        Passport::enablePasswordGrant();
    }
}

Congrats. You completed all the steps and HERE WE GO. You are ready to test your API.

You will get all the code in this git repository for your help.

Install Husky in your project for proper commit lint with pre-commit hooks

M H Hasib — Wed, 30 Aug 2023 04:45:05 +0000

Many of us write code. But how many of us write code properly with proper comment or proper linting. Also, most of us use git, but how many of us maintain proper git commit message. Proper commit message help us to find the particular code as well as we can easily understand which code contain the commit. So int this tutorial, we are going to learn about few topic. There are:

Install husky with commit proper formation
Husky pre-commit hooks

1. Install husky with commit proper formation:

First of all, we need to install Husky. So let's start by installing Husky. To install Husky Run the following command.

npm install husky --save-dev

Next, you also need to install commitlint to lint commits:

npm install @commitlint/cli --save-dev
npm install @commitlint/config-conventional --save-dev

Next, enable Git hooks using the following command:

npx husky install

Then, add the commit-msg hook using the following command:

npx husky add .husky/commit-msg 'npx commitlint --edit $1'

Next, create a file in your git root directory named .commitlintrc.json and add the following configuration:

{
  "extends": ["@commitlint/config-conventional"]
}

Then, create another file in the same directory named commitlint.config.js and the add the following configuration:

 module.exports = {
  extends: ['@commitlint/config-conventional'],
};

Finally, add a Git commit that doesn’t follow the convention:

git commit -a -m "Set up Husky and commitlint"

The operation should be failed with the following message:

⧗   input: Add Husky and commitlint
✖   subject may not be empty [subject-empty]
✖   type may not be empty [type-empty]

✖   found 2 problems, 0 warnings
ⓘ   Get help: https://github.com/conventional-changelog/commitlint/#what-is-commitlint

husky - commit-msg hook exited with code 1 (error)

Yes! Our commit message list is working!. Now lets try with the following commit lint which will work. Now run the following commit:

git commit -m 'feat: set up husky and commitlint'

BTW, you will get the linting formation in commitlint.

2. Husky pre-commit hooks:

So, here is the second part of our tutorial where we are going to implement the pre-commit hooks. But we need to know why we need pre-commit hooks. Sometimes we forget to format our code for with prittier, eslint or Laravel Pint. Sometimes its tough to remember to run the linting command before commit and push into the git repository. Here pre-commit hooks helps us. So lets install the husky pre-commit hook configuration. To install pre-commit hook run the following command:

npx husky-init npm install
npm run prepare

This will generate a file named pre-commit inside the .husky folder.

This file will contain the following configuration. It will generate a demo pre-commit which is npm test.

#!/usr/bin/env sh
. "$(dirname -- "$0")/_/husky.sh"

npm test

Now you need to modify the command you want to run before your commit. For example, you are working with in a Laravel Project and you want to format your code with Laravel Pint. So you can modify your code according your need like this.

#!/usr/bin/env sh
. "$(dirname -- "$0")/_/husky.sh"

./vendor/bin/pint

You can find a scenario when it will run Laravel pint command, it will run through all the file you changes. But if you want to run the specific file like that you add some specific file in git and you want to run the Laravel pint only these files. Then do the following code.

#!/usr/bin/env sh
. "$(dirname -- "$0")/_/husky.sh"

files=$(git diff --cached --name-only --diff-filter=ACM -- '*.php');
vendor/bin/pint $files -q

git add $files

You can add more command as you want. That's all for now.

Thanks for your time.

Use SweetAlert2 with Laravel Livewire

M H Hasib — Tue, 22 Jun 2021 19:50:45 +0000

Recently I've been doing a lot of Laravel Livewire stuff and truth to be told, I'm falling in love with it.

One of the common things to do in a web application is showing toast notifications. In this article, I'll be sharing a strategy I've been following for a while now.

Let's jump to implementing Sweet Alert 2 with Laravel Livewire.

Step 1:

First of all, we need to install Sweet Alert 2. You can install it through npm.

npm install sweetalert2

Or you can use this through CDN. In this article, I am going to use with CDN.

<script src="//cdn.jsdelivr.net/npm/sweetalert2@11"></script>

Put this CDN in your Main Layout.

Step 2:

Now, If you use this in Laravet Livewire, you should have a Livewire Component and Class. So in that class, after doing an action you need to dispatch a browser event. Now put this code into your action.

For livewire 2

$this->dispatchBrowserEvent('swal', [
    'title' => 'Item has been removed.',
    'icon'=>'success',
    'iconColor'=>'blue',
]);

For livewire 3

$this->dispatch('swal', [
    'title' => 'Item has been removed.',
    'icon'=>'success',
    'iconColor'=>'blue',
]);

Step 3:

Now you need to listen to this event so that it can fire an action to show the Sweet Alert Message. Now put this code to listen to the event which is fired from the Component Class.

<script>
    window.addEventListener('swal',function(e) {
        Swal.fire({
            title:  e.detail.title,
            icon: e.detail.icon,
            iconColor: e.detail.iconColor,
            timer: 3000,
            toast: true,
            position: 'top-right',
            toast:  true,
            showConfirmButton:  false,
        });
    });
</script>

Here we go... We have done our job.

Here I am sharing a GitHub Repository for making you better understand how you can use it.

Here I used this code as partials/_swal.blade.php.

<script>
    window.addEventListener('swal',function(e) {
        Swal.fire({
            title:  e.detail.title,
            icon: e.detail.icon,
            iconColor: e.detail.iconColor,
            timer: 3000,
            toast: true,
            position: 'top-right',
            toast:  true,
            showConfirmButton:  false,
        });
    });
</script>

Then I imported it in layouts/app.blade.php. You can easily understand it after seeing this repository.

Laravel Has Many Through Relationship Explained with Example

M H Hasib — Thu, 27 May 2021 18:11:05 +0000

Eloquent Relationships is one of the most useful and powerful features of the Laravel Framework. It is one of the reasons why I like Laravel most. Mainly it helps us to fetch or insert data in a very easy and efficient way.

As we know there are several types of relationships in Laravel. We (developers) use the first four of the most. These are: One To One, One To Many, One To Many (Inverse) / Belongs To, Many To Many.

I like Many To Many and Has Many Through most. Honestly speaking I enjoy these two relations most. Today I will explain Has Many Through with an easy example. I hope you'll be very clear after finishing this article.

So let's jump to our main section.

Let us have a scenario where we are creating a restaurant's items/menu and Items belongs to the Type and Types belongs to Category.

In simple words Category has many Types and Type has many Items. Now if we want all the Items which belongs to the Category, we need to keep the category_id in items table. But out items mainly belongs to Type. Basically Items are directly connected to Types.

So it's the case where we should use Has Many Through. By this kind of relation, we can fetch the data via another model. Like our scenario, we can directly fetch Items from Category via Types.

For your better understand I have created a GitHub Repository. You can visit this repository if you want. There I gave two types of examples for Has Many Through.

I try to give a very simple example so that I can make you understand easily. So, Let's start.

As I mentioned earlier that we are work with Category, Type, and Item.

So I make my migration very simple.

Here is my migration for Category. Let's have a look at this.

<?php

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

class CreateCategoriesTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('categories', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('categories');
    }
}

You can see I kept only category name here.

Let's have look at my Category Model.

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Category extends Model
{
    use HasFactory;

    /**
     * The attributes that are mass assignable.
     *
     * @var array
     */
    protected $fillable = [
        'name',
    ];
}

Here is my types migration. Let's have a look.

<?php

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

class CreateTypesTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('types', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->unsignedInteger('category_id');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('types');
    }
}

I just kept category_id as foreign key. So Category is connected with Type.

Here is the Type model.

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Type extends Model
{
    use HasFactory;

    /**
     * The attributes that are mass assignable.
     *
     * @var array
     */
    protected $fillable = [
        'name', 'category_id'
    ];
}

You might find it very simple.

Let's jump to my Items Migration.

<?php

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

class CreateItemsTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('items', function (Blueprint $table) {
            $table->id();
            $table->string('name');
            $table->longText('description');
            $table->unsignedInteger('type_id');
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('items');
    }
}

So here you can see that I just kept type_id as a foreign key. So Type is connected with Item. I didn't keep any category_id in Items Migration. Here is the main fact you need to understand that Item is not directly connected with Category. Item is connected with Category via Type. So that's why it's called Has Many Through relationship.

Now here is the model for Item.

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Item extends Model
{
    use HasFactory;

    /**
     * The attributes that are mass assignable.
     *
     * @var array
     */
    protected $fillable = [
        'name', 'description', 'type_id'
    ];
}

Now we will build a Has Many Through Relationship from Category to Item.

Let's create this relation to Category model.

<?php

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;

class Category extends Model
{
    use HasFactory;

    /**
     * The attributes that are mass assignable.
     *
     * @var array
     */
    protected $fillable = [
        'name',
    ];

    /**
     * Get all of the items for the user.
     */
    public function items()
    {
        return $this->hasManyThrough(Item::class, Type::class);
    }
}

Here items is the relation that will fetch all the items that belongs to the category via type.

You can also use relation like this:

 return $this->hasManyThrough(
        Item::class,
        Type::class,
        'category_id', // Foreign key on the types table...
        'type_id', // Foreign key on the items table...
        'id', // Local key on the users table...
        'id' // Local key on the categories table...
 );

There it goes. Our Has Many Through relationship has been build up successfully.

I want to give you another scenario where you can use this relationship for your better understand.

Scenario

Suppose we have three models.

Team (id, user_id, name)
User (id, name)
Goal (id, user_id, no.of goals)
So, the relationship is like this.

Team hasMany User (team_id inside User model)

User hasMany Goal (user_id inside Goal model)

See, from the relationship, we can see that here, the User model is an intermediary model.

We can not store the goal_id directly to the Team table because we already store the goal_id in the User table.

So, now the User model is in a relationship with the Team model. So, inside the User model, there is team_id.

Finally, if we need to access how many goals the Team has created then, we can go through User model.

If that type of scenario is generated for your use case then and then you need to define Has Many Through relationship.

I hope it is clear now.

Update existing table's column with migration without losing data in Laravel

M H Hasib — Thu, 20 May 2021 09:34:55 +0000

Before going to start our coding we need to know about Laravel Migration and how it helps us.

First of all, if we want to build a project. We need to design our database first. So what can we do? We can design our database directly. If you miss some field/column or some datatype, you need to fix it directly into the database which is a bad practice in Laravel.

In another scenario, Suppose you have a project and it needs to set up to your friend's device, you might need to send the SQL file; which is painful.

Now think if you have the feature like you pull the project and run a command, Boom your database is being set up. Isn't it very helpful?

Laravel migration does the same. You don't need to take the pain of SQL file or if you miss a data type or any spelling mistake, you can fix it through your coding. You need not work directly with the database. You will fix it to your code and just run php artisan migrate:refresh. So hopefully you got the benefit of Laravel migration.

Now let's jump to another scenario.

Sometimes we are much worried when we need to add or modify our existing database table.

For example, we have a User Model and users migration table and it contains name, username, email_verified_at password.

<?php

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

class CreateUsersTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::create('users', function (Blueprint $table) {
            $table->bigIncrements('id');
            $table->string('name');
            $table->string('email')->unique();
            $table->timestamp('email_verified_at')->nullable();
            $table->string('password');
            $table->rememberToken();
            $table->timestamps();
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::dropIfExists('users');
    }
}

But after deploying our project and after having our many users we found, we need to add a new field in our table like phone_number. Also mentioned, we need to keep our existing data.

So, we will create a new migration file for adding a new column in our existing table.

Now use this command:

php artisan make:migration add_phone_number_to_users_table

Here we need to ensure that the table's name needs to match the new migration file like we use users in both places.

After using the command we can see a new migration file like this:

<?php

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

class AddPhoneNumberToUsersTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::table('users', function (Blueprint $table) {
            //
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::table('users', function (Blueprint $table) {
            //
        });
    }
}

Now you can add your desire field in this migration file. As we need a phone_number field.

<?php

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

class AddPhoneNumberToUsersTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->string('phone_number')->unique()->after('email');
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::table('users', function (Blueprint $table) {
            //
        });
    }
}

Here we added phone_number field after email in up() method. You have the flexibility to put that column where ever you want by using after() or before(). You can learn more modifier from Laravel Documentation Column Modifier

Now we are one step behind from our job done.

<?php

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

class AddPhoneNumberToUsersTable extends Migration
{
    /**
     * Run the migrations.
     *
     * @return void
     */
    public function up()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->string('phone_number')->unique()->after('email');
        });
    }

    /**
     * Reverse the migrations.
     *
     * @return void
     */
    public function down()
    {
        Schema::table('users', function (Blueprint $table) {
            $table->dropColumn('phone_number');
        });
    }
}

Here you can see that we are adding $table->dropColumn('phone_number'); so that if we run the rollback command and it will work properly. If you have many filed you can use array of dropcolumn like this $table->dropColumn(['phone_number']);

And finally, here we go...

Now you need to run this command:

php artisan migrate

And we have done our job. :D

You can visit Laravel Migration Documentation for more migration options.

Hope it will help you.

DEV Community: M H Hasib

Laravel Passport: API authentication with access and refresh token

RegisterRequest:

LoginRequest:

RefreshTokenRequest:

One more suggestion:

Suggested Reads

Install Husky in your project for proper commit lint with pre-commit hooks

1. Install husky with commit proper formation:

2. Husky pre-commit hooks:

Use SweetAlert2 with Laravel Livewire

Suggested Reads

Laravel Has Many Through Relationship Explained with Example

Suggested Reads

Update existing table's column with migration without losing data in Laravel