Forem: Mahfuzur Rahman Saber

Run Laravel Pint With a Single Keyboard Shortcut in PhpStorm

Mahfuzur Rahman Saber — Mon, 30 Jun 2025 23:48:26 +0000

PhpStorm’s External Tools have been around for ages—perfect for running command-line formatters like Laravel Pint only when you decide.

Why ditch the auto-save watcher?
In short, a keyboard shortcut keeps intentional control over when Pint rewrites your code.

Below is a zero-overhead setup that maps Pint to your favorite shortcut (⌥ ⌘ L in this example). Note that, of course you can use any shortcut you like but I replaced reformat code shortcut with Pint as it made sense to me.

Prereqs: a Laravel project with Pint installed
composer require --dev laravel/pint
You’ll need PhpStorm 2023.2+ for built-in Pint support. Read more

Configure Laravel Pint in PhpStorm

As this article is not about how to configure I suggest you to read this article from PhpStorm Docs

Create the external tool

Preferences → Tools → External Tools →

Setting	Value
Name	Laravel Pint
Program	`$ProjectFileDir$/vendor/bin/pint`
Arguments	$FileRelativePath$
Working directory	$ProjectFileDir$
Advanced options	Uncheck Open console for tool output (optional – I leave it off because the pop-up gets annoying)

Bind it to a keyboard shortcut

Preferences → Keymap

Expand External Tools → Laravel Pint.
Right-click → Add Keyboard Shortcut.
Press ⌥ ⌘ L (or any combo).
If PhpStorm asks to remove the binding from Reformat Code, choose Remove—or pick a different shortcut if you’d rather keep the built-in formatter separate.

Happy (intentional) formatting! 🎉

PHP generators for large datasets.

Mahfuzur Rahman Saber — Mon, 22 Jul 2024 00:56:50 +0000

Visualizing memory usage with and without using generators can help understand the efficiency benefits. Below is a comparison of memory usage in two scenarios:

Without using generators (loading all data into memory at once).
Using generators (loading one item at a time).

Scenario 1: Without Generators

Let's say we have a simple function that returns an array of numbers from 0 to 999,999. This function loads all the data into memory at once.

<?php
function getNumbersArray() {
    $numbers = [];
    for ($i = 0; $i < 1000000; $i++) {
        $numbers[] = $i;
    }
    return $numbers;
}

$numbers = getNumbersArray();
foreach ($numbers as $number) {
    // Process each number
}
?>

Memory Usage (Without Generators)

When the function getNumbersArray is called:

Initial memory: Low, only the function and environment setup are in memory.
During execution: As the loop runs, the memory usage increases linearly, holding all 1,000,000 numbers in an array.
Peak memory: Very high, holding all the data in memory simultaneously.
After execution: Memory remains high until the script ends or the array is explicitly unset.

|            Memory Usage Without Generators           |
|------------------------------------------------------|
| Start    | *                                         |
|          | **                                        |
|          | ***                                       |
|          | ****                                      |
|          | *****                                     |
|          | ******                                    |
|          | *******                                   |
| ...      | ******************************************|
| End      | ******************************************|
|------------------------------------------------------|

Scenario 2: Using Generators

Now, we use a generator function to yield numbers one at a time.

<?php
function numberGenerator() {
    for ($i = 0; $i < 1000000; $i++) {
        yield $i;
    }
}

foreach (numberGenerator() as $number) {
    // Process each number
}
?>

Memory Usage (Using Generators)

When the generator function numberGenerator is called:

Initial memory: Low, only the function and environment setup are in memory.
During execution: Memory usage remains low as only one number is held in memory at a time.
Peak memory: Low, only one item plus overhead for the generator.
After execution: Memory usage drops immediately after the iteration ends.

|            Memory Usage With Generators              |
|------------------------------------------------------|
| Start    | *                                         |
|          | *                                         |
|          | *                                         |
|          | *                                         |
|          | *                                         |
|          | *                                         |
|          | *                                         |
| ...      | *                                         |
| End      | *                                         |
|------------------------------------------------------|

Summary

Without Generators: Memory usage increases with the size of the dataset and remains high throughout the script execution.
With Generators: Memory usage remains constant and low, regardless of the dataset size, because only one item is processed at a time.

Generators provide significant memory efficiency benefits, especially for large datasets, by yielding one item at a time and maintaining low memory usage throughout the script's execution.

Track User Online Activity Accurately In Laravel

Mahfuzur Rahman Saber — Mon, 02 Jan 2023 03:44:21 +0000

When you are working with laravel applications you may need to track users online activity such as are they currently logged in or not or how many user's are currently active. There are so many solution available in the internet also in ChatGPT 😏 by the way, however I found this approach which is returns more accurate result.

To get started you need to prepare the following structure

Migration (One to One - Polymorphic Relationship)
A Middleware (i.e. LoginActivity.php)
Events and Listener (i.e. LoginDetailEvent.php, LoginDetailListener.php)
A Model (i.e. LoginDetails.php)
Map events to the listener (i.e. EventServiceProvider.php)

Migration (One to One - Polymorphic Relationship)

Create a migration file named CreateLoginDetailsTable
add this code in the up method

Schema::create('login_details', function (Blueprint $table) {
    $table->id();
    $table->boolean('loggedin_status')->default(0);
    $table->timestamp('last_seen')->nullable();
    $table->unsignedBigInteger('loginable_id');
    $table->string('loginable_type');
    $table->string('type', 255)->nullable();
    $table->timestamps();
});

Middleware

This middleware will check if user is authenticated or not, if authenticated then logic will run or it will send the request to next.

Let's take a look at the code snippet.

use App\Events\LoginDetailEvent;
use Closure;
use Illuminate\Http\RedirectResponse;
use Illuminate\Http\Request;
use Illuminate\Http\Response;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Cache;

class LoginActivity
{
    /**
     * Handle an incoming request.
     *
     * @param Request $request
     * @param Closure(Request): (Response|RedirectResponse) $next
     * @return Response|RedirectResponse
     */
    public function handle(Request $request, Closure $next)
    {
        if (Auth::check()) {
            // keep online for 2 min
            $expireAt = now()->addMinutes(2);

            // if isOnline cache is found
            if (Cache::has('isOnline')) {
                // modify the isOnline cache data
                $onlineUsers = json_decode(Cache::get('isOnline', []), true);
            }
            // if isOnline cache is not found
            // add auth user id and current time in key, value pair to the cache
            $onlineUsers[Auth::id()] = now();
            // put modified/new value to isOnline cache with expiry time
            Cache::put('isOnline', json_encode($onlineUsers), $expireAt);

            // update last seen status
            event(new LoginDetailEvent(Auth::user()));
        }
        return $next($request);
    }
}

In this code we are setting an expiry time at the beginning after checking authentication. We are storing online user's activity in database and cache to get accurate result, here we are checking if there is any online user from the cache named isOnline. If user is available modify the isOnline cache data, add auth user id and current time in key, value pair to the cache, put modified value to isOnline cache with expiry time and lastly update last seen status. If user is not available then add auth user id and current time in key, value pair to the cache, put new value to isOnline cache with expiry time and lastly update last seen status.

Event and Listener

These events will fire and will be automatically listened when the user is authenticated or logged out. We have one listener who handles multiple tasks.

Such as,

fire Login event when user is authenticated
fire Logout event when user is logged out
fire LoginDetailEvent event to update last seen status

Let's take a look at the code snippet for that listener.

use App\Events\LoginDetailEvent;
use App\Models\LoginDetails;
use Illuminate\Auth\Events as LaravelEvents;
use Illuminate\Support\Facades\Auth;

class LoginDetailListener
{
    /**
     * This will store activity when login event is triggered
     *
     * @param LaravelEvents\Login $event
     */
    public function login(LaravelEvents\Login $event)
    {
        $this->fireAuthActivityEvent($event);
    }

    /**
     * This will store activity when logout event is triggered
     *
     * @param LaravelEvents\Logout $event
     */
    public function logout(LaravelEvents\Logout $event)
    {
        $this->fireAuthActivityEvent($event);
    }

    /**
     * Handle user's last seen status only
     *
     * @param  LoginDetailEvent $event
     */
    public function handleLastSeenStatus(LoginDetailEvent $event)
    {
        if (!\request()->ajax()) {
            if (Auth::check()) {
                $event->user->loginDetails()->update([
                    'last_seen' => now(),
                    'type' => $event->user->roles[0]->name
                ]);
            }
        }
    }

    /**
     * Update login activity based on user event login or logout
     *
     * @param $event
     */
    private function fireAuthActivityEvent($event)
    {
        if (Auth::check()) {
            if ($event instanceof LaravelEvents\Login) {
                $event->user->loginDetails()->updateOrCreate(
                    [
                        'loginable_id' => $event->user->id,
                        'loginable_type' => $event->user->loginDetails()->getMorphClass()
                    ],
                    [
                        'loggedin_status' => LoginDetails::STATUS['ONLINE'],
                        'last_seen' => now(),
                        'type' => $event->user->roles[0]->name
                    ]
                );
            } elseif ($event instanceof LaravelEvents\Logout) {
                $event->user->loginDetails()->update([
                    'loggedin_status' => LoginDetails::STATUS['OFFLINE'],
                    'last_seen' => now(),
                    'type' => $event->user->roles[0]->name
                ]);
            }
        }
    }
}

Let's take a look at the code snippet.

use Illuminate\Queue\SerializesModels;

class LoginDetailEvent
{
    use SerializesModels;

    public $user;

    /**
     * Create a new event instance.
     *
     * @return void
     */
    public function __construct($user)
    {
        $this->user = $user;
    }
}

Model

Here is the code snippet for the model.

use Illuminate\Database\Eloquent\Model;
use Illuminate\Support\Collection;
use Illuminate\Support\Facades\Auth;
use Illuminate\Support\Facades\Cache;

class LoginDetails extends Model
{
    public const STATUS = [
        'ONLINE' => 1,
        'OFFLINE' => 0
    ];

    protected $guarded = [];

    protected $casts = [
        'loggedin_status' => 'int'
    ];

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

    /**
     * @param  null $type
     * @return Collection
     */
    public function getOnlineUsers($type = null): Collection
    {
        // get all users from cache
        $cachedUsers = json_decode(Cache::get('isOnline', []), true);

        $onlineUsers = null;
        // if there are any
        if ($cachedUsers && count($cachedUsers)) {
            // get all online users by their user id except own id
            $onlineUsers = $this->whereIn('loginable_id', array_keys($cachedUsers))
                ->where('loginable_id', '!=', Auth::id())
                ->where('loggedin_status', '=', 1)
                ->when(!is_null($type), function ($query) use ($type) {
                    $query->where('type', '=', $type);
                })
                ->get();
        }

        return $onlineUsers;
    }
}

add this code in app/Models/User.php

/**
* @return MorphOne
*/
public function loginDetails()
{
    return $this->morphOne(LoginDetails::class, 'loginable');
}

Register to EventServiceProvider

In the $listens property of app/Providers/EventServiceProvider.php we have to register the event and listener.

protected $listen = [
      Login::class => [
          LoginDetailListener::class . '@login'
      ],
      Logout::class => [
          LoginDetailListener::class . '@logout'
      ],
      LoginDetailEvent::class => [
          LoginDetailListener::class . '@handleLastSeenStatus'
      ]
];

I hope this will help you and save your tons of hours. Cheers ... 🍻

Twitter | LinkedIn | GitHub | Portfolio | Upwork

Blade Component and Directive for Demo App - 2 (Pull like package using Git and GitHub)

Mahfuzur Rahman Saber — Sun, 11 Sep 2022 14:19:09 +0000

In the last blog I have explained how you can create a quick login blade component for your demo app. Also said that I will share a trick so you don't have to copy paste all codes in your every project. So let's take a look how we can achieve this.

Before push prepare structure

.
├── app
│   ├── Http
│   │   └── Controllers
│   │       └── Auth
│   │           └── LoginAsDemoLayout.php
│   └── View
│       └── Components
│           └── Demo
│               └── LoginAsController.php
└── resources
    └── views
        └── components
            └── demo
                ├── buttons
                │   └── login-as.blade.php
                └── login-as-demo-layout.blade.php

Why structuring files is important ? Basically when we pull we actually want those specific files to add in our project, which means if your file name matches with existing project files it will not pull instead it will create git conflict. Well this blog is not in-depth about git so I am not going to discuss all. To know more about git you need to do a bit of self study.

Push code to GitHub

First create a repo in GitHub

Initialize git, add and commit your files

git init

git add .

git commit -m 'your message'

connect your git repo

git remote add origin "your git url"

push your code

git push -u origin main

Pull from GitHub

Now you can pull these files from your any application by simply adding the upstream and pull.

add upstream

git remote add demo-comp https://github.com/SaaberDev/demo-app-component.git

You might have noticed I added the upstream but instead origin I named it as "demo-comp", why ? Because, we already have an upstream named origin where we are pulling.

After adding upstream simply use this command to pull.

git pull demo-comp main

Sometimes you may face issue like "refusing to merge unrelated histories" to solve this add --allow-unrelated-histories

git pull demo-comp main --allow-unrelated-histories

I hope this blog will help you to save your time. From now on you can reuse your code by simply creating a reusable repo and pulling it. This is a simple example but you can use your own technique.

Blade Component and Directive for Demo App

Mahfuzur Rahman Saber — Sat, 10 Sep 2022 21:44:56 +0000

As a beginner when you build demo projects you may wish to showcase your project without sharing credentials. So you need to create a way to login for demo app. It is very simple to do. But why not we make component for that. For me it looks elegant. Let's take a look how we can achieve this.

First we will create a layout for that specific section.

php artisan make:component Demo/LoginAsDemoLayout

This will generate a blade component in resources/views/components/login-as-demo-layout.blade.php

Put this code over there.

<div>
    <div class="row justify-content-center mt-3">
        <div class="col-md-12">
            {{ $slot }}
        </div>
    </div>
</div>

@push('scripts')
    <script>
        $(document).ready(function () {
            $('.login_as').on('click', function () {
                var $_role = $(this).attr('id').replace('login_as_', '');
                $.ajax({
                    url: "{{ route('login_as') }}",
                    type: "POST",
                    data: { param: $_role },
                    headers: {
                        'X-CSRF-TOKEN': $('meta[name="csrf-token"]').attr('content')
                    },
                    success: function (data) {
                        window.location.href = data.redirect
                    }
                });
            });
        });
    </script>
@endpush

Now create a button component without creating class for that named login-as.blade.php in resources/views/components/demo/buttons

Copy and paste this code over there.

<div>
    @foreach($roles as $role)
        <button id="login_as_{{ $role }}" class="login_as btn btn-primary btn-block">Login as {{ ucwords(preg_replace('/[-,_]/', ' ', $role)) }}</button>
    @endforeach
</div>

Now you may wonder where this $roles came from. Here is the magic of blade components.

Put this code where you want to show your buttons.

<x-demo.login-as-demo-layout>
     <x-demo.buttons.login-as :roles="['super-admin', 'admin', 'manager']"/>
</x-demo.login-as-demo-layout>

x-demo.login-as-demo-layout - this is the main layout for what i want to display in the demo section.
x-demo.buttons.login-as - these are the buttons

If you notice you will see in x-demo.buttons.login-as there is something like attribute which is actually called a prop :roles. This prop act like a variable. So we can pass anything in the variable.

In this scenario, we passed an array which means we can add as many item as we need. Now let's say you have a new role instead of doing manually you can push another item in the array. You can pass the role dynamically from your database as well. Which is pretty cool right ?

Now let me show you another cool part and it is called Blade If Directive.

Imagine you want to disable your demo section.

So simply you can do this.

add a key APP_DEMO in the .env and set it to true
add that key in config/app.php

'demo' => env('APP_DEMO', 'false'),

perform if condition in code

@if(config('app.demo') === true)
show content
@endif

But isn't this traditional way. Why not create a permanent directive for demo only.

Just follow above steps except if condition part and copy this simple code inside boot method in AppServiceProvider.

Blade::if('_demo', function () {
    return config('app.demo') === true;
});

Usage

@_demo
{{-- Login As Component --}}
<x-demo.login-as-demo-layout>
    <x-demo.buttons.login-as :roles="['super-admin', 'admin', 'manager']"/>
</x-demo.login-as-demo-layout>
@end_demo

If in some case it does not work. Run this command.

php artisan view:clear

Now you may thinking why I did not put ajax's controller code in the beginning of this blog, well that's because this is not the scope of this blog, also it depends how you want to create your own controller. May be you want to see how I did. Here it is.

Simply create an invokable controller

php artisan make:controller Auth/LoginAsController --invokable

and paste this code in there

public function __invoke(Request $request)
{
    $login_as = $request->get('param');
    $find_user = function ($email) {
        $this->user =  User::where('email', '=', $email)->first();
    };

    match ($login_as) {
        'super_admin' => $find_user(SUPER_ADMIN),
        'admin' => $find_user(ADMIN),
        'manager' => $find_user(MANAGER),
        'default' => 'Could not find user'
    };

    Auth::login($this->user);

    return response()->json([
        'msg' => 'Logged in successful',
        'redirect' => redirect()->intended()->getTargetUrl() // use appropriate url where you want to redirect
    ]);
}

I personally use this in all my application. You can code once and use it in all your projects using a simple Git Pull command. I will explain this in next blog.