DEV Community: Karan Datwani

4 Ways To Prevent Race Conditions in Laravel

Karan Datwani — Mon, 07 Jul 2025 11:48:00 +0000

Imagine two users trying to update the same record at the exact same time. If your app isn’t handling this properly, one update might overwrite the other, leading to incorrect results. This issue is called a race condition, and it can cause unexpected bugs.

Consider an online payment system where a user’s account balance is updated. If two transactions occur at nearly the same time, they might read the same balance before either updates it—resulting in incorrect deductions.

Is your app facing race conditions? It’s time to fix that. In this article, we’ll look at the benefits and four ways to prevent race conditions. This will help keep data safe and performance smooth.

Benefits of Preventing Race Conditions

Keeps Data Accurate – Prevents critical information from being overwritten or corrupted.
Avoids Lost Updates – Makes sure every change is saved, even during high traffic.
Improves Stability – Reduces strange bugs and makes your app more reliable.
Increases Safety – Blocks conflicting or unauthorized updates in real time.
Handles High Concurrency Smoothly – Prevents bottlenecks and errors when many users interact with the same data at once.

Strategies to Prevent Race Conditions

1. Database Transactions

Ensure multiple operations succeed or fail together. If anything breaks, the transaction rolls back, preserving data consistency.

Example:

A bank transfer where money is deducted from one account but fails to reach the other.

Solution:

DB::transaction(function () {
    $sender = User::find(1);
    $receiver = User::find(2);

    $sender->balance -= 100;
    $receiver->balance += 100;

    $sender->save();
    $receiver->save();
});

✅ If any step fails, Laravel rolls back all changes.

2. Pessimistic Locking

Locks a record for the current operation, blocking others until it finishes. Great for high-traffic scenarios.

Example:

Two customers try to buy the last item in stock.

Solution:

$product = Product::where('id', 1)->lockForUpdate()->first();

if ($product->stock > 0) {
    $product->stock -= 1;
    $product->save();
} else {
    throw new Exception("Out of stock!");
}

✅ Ensures only one transaction can update the stock at a time.

3. Optimistic Locking

Checks if a record changed before saving updates. Useful when many users may modify the same data.

Example:

Two employees update a product’s stock simultaneously.

Solution:

$product = Product::find(1);

if ($product->updated_at->timestamp === request('updated_at')) {
    $product->stock += request()->added_stock;
    $product->updated_at = now();
    $product->save();
} else {
    throw new Exception("Stock data changed. Please refresh and try again.");
}

✅ Prevents updates if the data has changed since it was read.

4. Atomic Operations

Let the database handle updates in a single step—no fetch or manual save needed.

Example:

Multiple users try to withdraw money from the same account.

Solution:

User::where('id', 1)->decrement('balance', 100);

✅ The operation is handled directly in the database—no race condition.

Bonus Tip: Cache Locks

Use Laravel’s Cache::lock() to prevent multiple processes from running the same critical logic block.

Example:

Prevent multiple jobs from processing the same order at the same time.

Solution:

$lock = Cache::lock('process-order-123', 10); // Lock for 10 seconds

if ($lock->get()) {
    try {
        $order = Order::find(123);

        if ($order && $order->status === 'pending') {
        // Execute payment or fulfillment logic
            $order->status = 'processing';
            $order->save();
            dispatch(new ChargeCustomer($order));
        }
    } finally {
        $lock->release();
    }
} else {
    // Another process is handling it
    Log::info('Order 123 is already being processed.');
}

✅ Prevents race conditions across processes by using cache-based locking.

Final Word

Race conditions can mess up your data but Laravel gives you tools to stop them.
Use database transactions to guarantee all steps succeed together.
Apply pessimistic locking to block conflicts in real-time.
Use optimistic locking to catch conflicts before saving.
Rely on atomic operations to make safe one-step updates.

Don't leave data consistency to chance —build with confidence! 🚀

Share your thoughts or tips below.

🚀 Happy coding!

🍣 Sushi — Your Eloquent model driver for other data sources

Karan Datwani — Mon, 11 Nov 2024 06:54:46 +0000

In Laravel projects, we usually store data in databases, create tables, and run migrations. But not every bit of data needs that level of complexity. Sometimes, you have small, static datasets—like a list of countries, settings, or configs—that hardly ever change. Setting up a database table for everything can feel like overkill.

That’s where Sushi comes in. It’s a lightweight package that lets you skip the database entirely for small, static data, even pulling from APIs or config arrays.

What is Laravel Sushi?

Sushi allows you to create Eloquent models from data sources other than a database. Instead of setting up a traditional database, you can provide data from an array, config, API, or a CSV file. What I mean is... it can be anything.

It is created by Caleb Porzio (the guy behind Livewire and AlpineJS), Sushi simplifies your data when a full database table is unnecessary.

How to Use Sushi?

The simplest way to use Sushi is by providing data as a hardcoded array. But you can also pull dynamic data from an API or load it from a config array for flexibility. Let’s explore three examples:

Installation
Let's do the installation first.

composer require calebporzio/sushi

Example 1: Hardcoded Data

Here’s a basic model using a hardcoded array:

`php
<?php

namespace App\Models;

use Sushi\Sushi;

class Country extends Model
{
// Add the Sushi trait
use Sushi;

// Provide data as a hardcoded array
protected $rows = [
    ['id' => 1, 'abbr' => 'IN', 'label' => 'India'],        
    ['id' => 2, 'abbr' => 'US', 'label' => 'United States'],
];

}
`

Now, you can query it just like a regular database model:

php $india = Country::where('abbr', 'IN')->first();

Example 2: Data from a Config Array

You can also load the data from a config file. If you have data in some third-party config or you choose to keep the data outside the model, you can set up eloquent models from that data without going deeper into the code.

Let’s say you have a config file like this in config/countries.php:

`php
<?php

return [
['id' => 1, 'abbr' => 'IN', 'label' => 'India'],
['id' => 2, 'abbr' => 'US', 'label' => 'United States'],
];
`

Now, you can use Sushi to load this config data into a model:

`php
<?php

namespace App\Models;

use Sushi\Sushi;

class Country extends Model
{
use Sushi;

public function getRows()
{
    // Load the data from the config file
    return config('countries');
}

}
`

Example 3: Dynamic Data from an API with Caching

You can also implement Sushi where you pull data from an API. Here’s how you can fetch dynamic data from an API and cache it for an hour:

`php
<?php

namespace App\Models;

use Sushi\Sushi;
use Illuminate\Support\Facades\Http;
use Illuminate\Support\Facades\Cache;

class Country extends Model
{
use Sushi;

public function getRows()
{
    // Cache the API data for 1 hour
    return Cache::remember('countries', 60, function () {
        $response = Http::get('https://restcountries.com/v3.1/all');
        $countries = $response->json();

        // Map the API response to the format Sushi expects
        return collect($countries)->map(function ($country) {
            return [
                'id'    => $country['cca3'],
                'abbr'  => $country['cca2'],
                'label' => $country['name']['common'],
            ];
        })->toArray();
    });
}

}
`

In this example:

We’re fetching data from the REST Countries API.
The API response is cached for 1 hour using Laravel’s Cache::remember() method.
getRows() pulls and transforms the data into the format Sushi requires.

Why Use Sushi?

Sushi is perfect when you need a lightweight solution for static or semi-static datasets, like:

Configurations, lists of countries, or languages
Predefined roles or permissions
Any small dataset that doesn’t change often but still needs to be queried

You can skip the database entirely and enjoy the full power of Eloquent without the overhead of migrations and database setup.

One more cool thing: You don’t even need an id column unless you want to. Sushi can auto-generate IDs for each row. But keep in mind, if the data changes and the cache is reset, these IDs might change too. So, for stability, it’s best to define your own id column for each item.

Note: Since Sushi uses SQLite to store the data, make sure the SQLite extension is enabled in your PHP configuration.

Conclusion

Sushi lets you skip the database setup for smaller datasets and helps you define that data directly in the model, saving time and keeping things lightweight. It is a great tool when dealing with static data, configurations, or even dynamic data from APIs.

Just a side note, our core product CRUD is also compatible with Sushi and you can use it to create a Table for the entries. Our Backpack DevTools also uses Sushi, which shows how practical this tool is. Give it a try - save time and keep things light.🧑‍💻😎

Backpack - Configure User Access Control and Permissions in 10 minutes

Karan Datwani — Sun, 13 Oct 2024 10:17:29 +0000

Hey folks! So, picture this: you're crafting your admin panel and the need for proper access control hits you.

Admin panels without roles and permissions are like a party without bouncers – chaos waiting to happen. It's like giving everyone backstage access and waiting for disaster. We should return HTTP status code 403 to such unauthorized access events:

In this article, we'll learn to keep things organized, secure and ensure the right people have the right keys using Roles & permissions.

PermissionManager

To kick things off, I've equipped the Backpack project with the PermissionManager Addon.

Install composer require backpack/permissionmanager
Follow a few steps and prepare your user model;

Boom! Your user model is now flexing some access control muscles:

Claiming Territory with Role & Permissions

When crafting roles and permissions, start by identifying distinct user responsibilities. Define them using Roles & Permissions CRUD:

Permissions grant users access to specific actions or URLs;
Roles are your squad leaders, grouping permissions together;

For instance, distinguish between Admins and Editors. Create permissions for each role(examples: manage articles, manage tags). Admin role holders can swagger through CRUD operations while Editors only have access to:

Article CRUD and can perform actions like delete and edit on their posts only;
No access to Tags OR Category CRUD;

Remember, clarity is key! - Be granular and avoid unnecessary complexity.

Securing the Resources

To secure our admin panel, we need a bouncer at the gate. In our case, routes are the gates to our application and backpack_middleware() is the bouncer. In routes/backpack/custom.php, fortify your routes with backpack middleware:

Route::group([
    'prefix'     => config('backpack.base.route_prefix', 'admin'),
    'middleware' => ['web', backpack_middleware()],
    'namespace'  => 'App\Http\Controllers\Admin',
], function () {
    // admin routes    
    Route::crud('article', 'ArticleCrudController');
    Route::crud('category', 'CategoryCrudController');
    Route::crud('tag', 'TagCrudController');
});

We have placed a bouncer and he needs to know the rules to allow & deny user access, right?

Protecting Operations:

Each backpack operation comes with a simple access system. It works using an array $crud->settings['operation_name']['access'] which can either be true or false. All operations by default run CRUD::allowAccess('operation_name'); which toggle that variable to true.

You can add or remove elements to this access array in your setup() method using CRUD::denyAccess() & CRUD::allowAccess().

The following code is good enough to check the current user's permission (manage articles) and restrict access to its list, show, create, update and delete operations of Article CRUD:

use Backpack\CRUD\app\Library\CrudPanel\CrudPanelFacade as CRUD;

class ArticleCrudController extends CrudController
{

    public function setup(){
        // check permissions first
        if(!backpack_user()->can('manage articles')){
        // deny access to operations
            CRUD::denyAccess(['list','show','create','update','delete']);
        }

        /**
        ... rest of the code...
        **/
    }
}

To restrict per entry basis, I would add the following to it:

CRUD::operation(['list','update','delete'], function() {
    CRUD::setAccessCondition(['update', 'delete'], function ($entry) {
        return $entry->author_id === backpack_user()->id ? true : false;
    });
});

This will remove edit & delete buttons and restrict the form URLs for the posts which are not created by the currently logged-in user:

I find it cool, that small snippets take care of every single entry gate!

We also need to hide items from the menu. Admins should see only those menu items whose access they have. The following is a simple example of doing it using permissions:

// resources/views/vendor/backpack/ui/inc/menu_items.blade.php
@if(backpack_user()->can('manage articles'))
    <x-backpack::menu-item title="Articles" icon="la la-newspaper-o" :link="backpack_url('article')" />
@endif

@if(backpack_user()->can('manage categories'))
    <x-backpack::menu-item title="Categories" icon="la la-list" :link="backpack_url('category')" />
@endif

@if(backpack_user()->can('manage tags'))
    <x-backpack::menu-item title="Tags" icon="la la-tag" :link="backpack_url('tag')" />
@endif

How to make this work for Custom Operations?

To set access control for your custom operation trait, use the following steps:

Think of a key similar to your operation name or the action. Allow access to it while setting operation defaults via CRUD::allowAccess('publish');
Toggle visibility of UI elements such as button via @if ($crud->hasAccess('publish', $entry)) in the blade file;
Check access at the beginning of operation's function CRUD::hasAccessOrFail('publish');

For example:

protected function setupPublishDefaults()
{
    $this->crud->allowAccess('publish');

    // Set operation defaults
}

public function publish()
{
    CRUD::hasAccessOrFail('publish');

    // Custom operation logic
}

Protecting custom routes:

Other than CRUD operations, you may have other admin panel routes to protect.

Here, we would use Spatie's permission middleware. We can use it like can:list secrets:

Route::group([    
    'prefix'     => config('backpack.base.route_prefix', 'admin'),
+  'middleware' => ['web','can:list secrets', backpack_middleware()],
], function () {
    Route::get('secrets', 'SecretController@list');
});

Huuhoo! We restricted access to a custom route too!

You may want to Spatie's directives like `@role`, `@can`

Directive like @can, @role uses default laravel authentication guard. You can have two scenarios here:

Change the default guard in config.auth.defaults.guard to backpack. In this case, make sure your roles and permissios are using the backpack guard in the database.
Change the config.backpack.base.guard to null so backpack will also use the web guard. In this case, make sure web is the guard in the database for permissions and roles.

Depending on your project needs, one of the configuration could be the best to apply.

Conclusion

There you have it! Your admin panel is now a secure fortress. I hope you find this article an easy learn to implement access control on your admin panel.

When you need a quick fix, consult the following cheat codes:

// allow or deny access
CRUD::allowAccess(['list', 'create', 'delete']);
CRUD::denyAccess(['list', 'create', 'delete']);
CRUD::denyAllAccess();

// check access
CRUD::hasAccess('add'); // returns true/false
CRUD::hasAccess('add',$entry); // returns true/false
CRUD::hasAccessOrFail('add'); // throws 403 error
CRUD::hasAccessToAll(['create', 'update']); // returns true/false
CRUD::hasAccessToAny(['create', 'update']); // returns true/false

// allow or deny access depending on the entry
CRUD::operation(['list','update','delete'], function() {
        CRUD::setAccessCondition(['update', 'delete'], function ($entry) {
            return $entry->id===1 ? true : false;
    });
});

For more advanced features, head over to the PermissionManager or Spatie's package docs.

Happy coding! 🚀

Make Your WebApp or Admin Panel Installable as a Mobile App

Karan Datwani — Mon, 30 Sep 2024 08:35:13 +0000

Ever noticed a little icon or popup on your browser asking you to install the web app you're currently browsing? It’s a cool feature that lets users add a web app directly to their mobile home screen, just like a native app. Let's walk through how you can make your web app or admin panel installable!

What Is a Progressive Web App (PWA)?

A quick primer: this feature is part of what’s called a Progressive Web App (PWA). PWAs make your web app feel more like a native app, with the ability to be installed on a user’s device directly from their browser.

Spotify has it, I've seen many e-commerce using it. I personally utilize it for my e-commerce and some other mini-web apps.

How to Make Your Web App Installable

Here’s how you can make your web app installable as a mobile app with a simple manifest file.

Create a Manifest File: In your public directory, create a site.webmanifest with details like your app's name, start URL, and icons. Here’s a basic example:

{
    "name": "My Laravel Web App",
    "short_name": "WebApp",
    "start_url": "/",
    "display": "standalone",
    "background_color": "#ffffff",
    "theme_color": "#000000",
    "icons": [
        {
            "src": "/images/icons/icon-192x192.png",
            "sizes": "192x192",
            "type": "image/png"
        },
        {
            "src": "/images/icons/icon-512x512.png",
            "sizes": "512x512",
            "type": "image/png"
        }
    ]
}

Link the Manifest: Add this to the <head> of your main Blade layout:

<link rel="manifest" href="{{ asset('/site.webmanifest') }}">

And that’s it! Your Laravel web app is now ready to be installed on mobile devices directly from the browser. Visit your web app on a mobile or desktop browser like Chrome, or Safari. If everything is configured correctly, you should see an "Add to Home Screen" or "Install App" option added in the browser menu. You may also see a popup for the same if your browser supports it. Tap it and your web app will be installed just like a native mobile app.

Make Your Backpack AdminPanel Installable

Some apps or sites may not make sense to offer this feature to the public, but offering the admin panel as a native mobile app would definitely be a good experience for admins.

Backpack offers you to do the above with just a command:

php artisan backpack:publish-header-metas

This command will ask you a few questions, and then it will publish the necessary files and add the headers. Later, you customize them to fit your branding.

Conclusion

With a simple manifest file and a meta link in your Blade or HTML template, you can make your web app or admin panel installable on mobile devices. Try it out and make your web app more engaging!

And… Suppose you or your admin want real-time mobile notifications from your Laravel app. For example, when an order is received. In that case, You should check out our other article on receiving Slack notifications from your Laravel app with a 10-minute setup.

Receive Slack Notifications from your Laravel App with a 10-minute Setup

Karan Datwani — Sun, 22 Sep 2024 09:05:15 +0000

In the previous article, I introduced a Backpack's new Menu Dropdown Column component which I use for my e-commerce admin panel. Today, I will talk about a Laravel feature I use to receive Order Notifications. Whenever an order comes, my team is notified to ship it ASAP. You can assume the importance of receiving quick notifications for such events.

I also use it in:

Log Manager: To get notified of website error events ASAP.
Backup Manager: To get notified if the backup fails.
To receive notification if some Queued Job/Background running task fails.
To receive Daily reports.
And... Many events(Getting live updates fasten up the process)

Laravel officially supports it. Thus, many laravel packages supports it too.

In this tutorial, I assume you have a basic knowledge of Laravel Notifications and you know about Slack. Slack is a messaging app designed for business use. It can be used on desktop and mobile devices, making communications easy.

Create a Slack App

First, we need a Slack account to create a new #Channel & our Slack App. The following steps will help you to create one for your Laravel app.

Steps	Screenshot
1. Sign in on Slack & Start with free plan.
2. Go to https://api.slack.com/apps. Click on Create an app & select From scratch as we are building a simple app.
3. Next, you will be asked to create or select a workspace. Just name it.
4. After workspace, You can Create an App for that.
5. Name your Slack App & choose the workspace.
6. Next, click on Incoming Webhooks.
7. Activate! Incoming Webhooks & Click "Add New Webhook to Workspace".
8. Choose a channel where this webhook will send messages.
9. Final Step! Navigate to OAuth & Permissions. Add scopes such as `chat:write`, `incoming-webhook` ,`chat:write.public` and copy the OAuth Token.

Done! You need to paste the Token & Webhook URL into Your Laravel App to send notifications.

Package Installation

Install the official Slack Notification Channel package:

composer require laravel/slack-notification-channel

Paste the Webhook & Oauth Token in your Laravel configuration.

Use them within the slack configuration array in config/services.php. Your Laravel App is now ready to send notifications.

'slack' => [
    'notifications' => [
        'bot_user_oauth_token' => env('SLACK_BOT_USER_OAUTH_TOKEN'),
        'channel' => env('SLACK_BOT_USER_DEFAULT_CHANNEL'),
    ],
],

Send Notifications

In general, multiple channels are created depending on the type of notification. I created two more channels & two webhooks for each channel. For example: #orders, #errors-logs, #backup-logs.

Use webhook URL in the packages.

Each package that supports Slack notifications comes with a config file where we only need to configure the webhook URL.

For Backup Manager, paste the webhook URL in config/backup.php & enable the channel for package's notification class:

'notifications' => [
-    \Spatie\Backup\Notifications\Notifications\BackupHasFailedNotification::class => ['mail'],
+    \Spatie\Backup\Notifications\Notifications\BackupHasFailedNotification::class => ['slack'],
    ...            
    ],

'slack' => [
+   'webhook_url' => env('SLACK_BOT_BACKUP_WEBHOOK_URL'),           
    ...
],

For Log Manager, paste the webhook URL in config/logging.php to enable it:

'slack' => [
+   'url' => env('SLACK_BOT_ERROR_LOG_WEBHOOK_URL'),   
    ...
],

Thats it! These packages will be sending the notifications on their configured events.🔔

Creating a Custom Notification

Now let's talk about creating Notification as per our needs.

Command to create a notification class:

php artisan make:notification OrderNotification

Add a toSlack() method and format the notification:

use Illuminate\Notifications\Slack\SlackMessage;

public function toSlack($notifiable)
{
    return (new SlackMessage)
            ->to("#orders") // set the channel
            ->text('Check & update order status.')
            ->headerBlock('#'.$this->order->id.' Order Received🎉');
}

You can find a set of blocks here for formatting beautiful Slack notifications. You can also give action choices to the user with actionsBlock() available here.

Enable slack delivery channel for the notification:

public function via($notifiable)
{
-    return ['mail'];
+    return ['mail', 'slack'];
}

Tip: You can turn channels on/off for each Notification by conditionally altering the array.

Done! Our Notification is ready to send on Slack.

For a better understanding of Notificaton::class, You can check this Gist. I use it to send E-mail & SMS to user and receive Slack notification when an order gets placed.

We can send the notification in two ways; Using Trait and Facade:

Using Notifiable trait, For example we can use this in User Model:

<?php

namespace App\Models;

use Illuminate\Foundation\Auth\User as Authenticatable;
+ use Illuminate\Notifications\Notifiable;

class User extends Authenticatable
{
+    use Notifiable;
}

and then send (☝️ check Gist to see how i pass order information.):

$user->notify(new OrderNotification($order));

Another way is using Notification facade. This approach is useful when you need to send a notification to multiple notifiable entities such as a collection of users:

use Illuminate\Support\Facades\Notification;

Notification::send($users, new OrderNotification($order));

Notification::route('slack', env('SLACK_WEBHOOK'))->notify(new SimpleNotification());

Get more out of Slack Notifications

You can find a set of blocks here for formatting beautiful Slack Notifications. You can also give action choices to the user with actionsBlock() available here.

Conclusion

We often need to get notified when something happens on the App. Get timely updates from your Laravel application with the help of Slack notifications. You can set it up in just 10 minutes!

I hope this article was useful and saved you some time figuring out this yourself. Just don't get into Bombing your Slack channels😝!

Happy Coding!

Add Engaging Animations To Your Webapp for FREE

Karan Datwani — Mon, 09 Sep 2024 09:26:19 +0000

Lottie animations have become a popular choice for adding rich, engaging animations to websites and apps. They’re lightweight, scalable, and easy to implement, making them a go-to solution for designers and developers alike. In this tutorial, we'll explore what Lottie animations are, how to use them, and where to get them.

What is Lottie?

Lottie is a library developed by Airbnb that renders animations in real-time on the web and mobile apps. It reads JSON files exported from Adobe After Effects using the Bodymovin plugin, allowing complex animations to be easily integrated without compromising performance.

Why Use Lottie?

Lightweight: Compared to traditional video files or GIFs, Lottie animations are extremely small in size.
Scalable: Because they’re vector-based, Lottie animations remain crisp and clear at any size.
Cross-Platform: Lottie works seamlessly across different platforms, including web, iOS, and Android.
Easy to Integrate: With the Lottie library, implementing animations is straightforward, requiring just a few lines of code.
Community Resources: Lottie has an active community, sharing many animations for FREE.

Getting Started

LottieFiles is a go-to resource for Lottie animations. It provides a vast library of FREE and premium animations, tools for creating and editing animations, and even plugins for easy integration with many platforms like vanilaJS, React, VueJS, IOS, Android, etc.

Visit LottieFiles.com and search through categories to find animations that suit your needs. Download the animation you like in the JSON format.

Adding Lottie Animations to Your Project

Add an element where your animation will appear:

<canvas id="canvas" width="300" height="300"></canvas>

Include the Lottie Web library and play the animation with JavaScript:

<script type="module">
  import {DotLottie} from "https://cdn.jsdelivr.net/npm/@lottiefiles/dotlottie-web/+esm";

  new DotLottie({
    autoplay: true,
    loop: true,
    canvas: document.getElementById("canvas"),
    src: "https://lottie.host/4db68bbd-31f6-4cd8-84eb-189de081159a/IGmMCqhzpt.lottie", // or .json file
  });
</script>

Wanna Embed into HTML or Wordpress?

That's also possible. Here is an example of embedding a lottie animation:

<script src="https://unpkg.com/@lottiefiles/lottie-player@latest/dist/lottie-player.js"></script>

<lottie-player src="https://lottie.host/4c2a69ec-47c3-49ae-b296-8a4770ce5cf5/sl7OhHvAbk.json" background="#FFFFFF" speed="1" style="width: 300px; height: 300px" loop controls autoplay direction="1" mode="normal">
</lottie-player>

Where is IOS, Android, React or Vue.. integration?

For other platforms, find the suitable lottie player here.

Conclusion

Lottie animations offer a way to enhance the user experience with rich, high-quality animations. With resources like LottieFiles.com, integrating and customizing these animations has never been easier. Whether you're a designer or a developer, adding Lottie animations to your toolkit can elevate your projects and make them stand out.🥇

Thanks for reading. For more articles, you can subscribe to our newsletter.💬

Top 10 PHP Features You Can Use in 2024

Karan Datwani — Mon, 09 Sep 2024 09:05:20 +0000

Hey PHP fans! This article highlights some excellent new features of our favorite scripting language. Whether you're a seasoned pro or just starting out, these will make your coding life easier and more fun. Let's dive into the top PHP features you can use right now!

1. Readonly Properties

Let's say you don't want changes to a variable after initialization. Now, with readonly properties, you can set a property once and prevent it from being modified.

class User {
    public readonly string $username;

    public function __construct(string $username) {
        $this->username = $username;
    }
}

2. Enums

Enums are now a thing in PHP! They let you define a set of named values, perfect for things like statuses or categories.

enum Status {
    case PENDING;
    case ACTIVE;
    case INACTIVE;
}

$status = Status::ACTIVE;

3. Match Expressions

Match expression is a more flexible alternative to switch statements. They let you return values directly from each case.

$status = 'active';

$message = match ($status) {
    'active' => 'The user is active.',
    'inactive' => 'The user is inactive.',
    'pending' => 'The user is pending.',
    default => 'Unknown status.',
};

4. Constructor Property Promotion

Save time by defining and initializing properties directly in the constructor.

class Point {
    public function __construct(
        public float $x,
        public float $y
    ) {}
}

$point = new Point(1.5, 2.5);

5. Named Arguments

Named arguments make your code more readable by allowing you to pass values to a function by name instead of position.

function createUser(string $username, bool $isAdmin = false) {
    // Your code here
}

createUser(username: 'john_doe', isAdmin: true);

6. Nullsafe Operator

Avoid those annoying null checks with the nullsafe operator, which lets you call methods or access properties on an object only if it's not null.

$user = getUser();
$profile = $user?->getProfile()?->getBio();

7. Union Types

Type hinting just got more flexible with union types, allowing you to specify multiple types for a parameter or return value.

function processNumber(int|float $number): int|float {
    return $number * 2;
}

8. Array Unpacking with String Keys

Array unpacking with string keys, making it easier to merge arrays.

$array1 = ['a' => 1, 'b' => 2];
$array2 = ['c' => 3, ...$array1];

print_r($array2);
// Output: ['c' => 3, 'a' => 1, 'b' => 2]

9. JSON_THROW_ON_ERROR

With PHP 8.3, you can enable json.exceptions to throw JsonException by default on JSON errors.

ini_set('json.exceptions', '1');

try {
    $data = json_decode('{"invalidJson":}', true);
} catch (JsonException $e) {
    echo 'JSON Error: ' . $e->getMessage();
}

10. JIT Compilation

Just-In-Time (JIT) compilation is now part of PHP, making your scripts run faster by compiling parts of the code at runtime.

Wrapping Up

2024 is shaping up to be an exciting year for PHP developers. With these new features, you'll write cleaner, faster, and more readable code. So update your PHP version and start playing with these cool new features.

All the above have been previously shared on our Twitter, one by one. Follow us on Twitter; You'll ❤️ it. You can also check our FREE Laravel Advanced series to know trending Laravel features. Keep exploring, and keep coding. Until next time, happy coding! 🚀

Laravel Advanced: Top 10 Validation Rules You Didn't Know Existed

Karan Datwani — Fri, 12 Jul 2024 08:42:52 +0000

Do you know all the validation rules available in Laravel? Think again! Laravel has many ready-to-use validation rules that can make your code life a whole lot easier. Let’s uncover the top 10 validation rules you probably didn’t know existed.

1. Prohibited

Want to make sure a field is not present in the input? Use prohibited.

'username' => 'prohibited',

If username is included in the request, validation will fail. Simple and effective, especially for a honeypot!

2. Prohibits

Need a field to prohibit another field from being present? Check this out.

'password' => 'prohibits:username',

If password is present, username must not be.

3. Required If

This one’s a lifesaver when you need conditional validation.

'email' => 'required_if:contact_method,email',

The email field is required only if contact_method is email.

4. Required Unless

Opposite of required_if. Use it to require a field unless another field has a specific value.

'email' => 'required_unless:contact_method,phone',

Here, email is required unless contact_method is phone.

5. Required Without

This rule is great when you need a field only if another field isn’t present.

'email' => 'required_without:phone',

If phone isn’t provided, email must be.

6. Required Without All

Step up your game by requiring a field if none of the other specified fields are present.

'email' => 'required_without_all:phone,address',

If neither phone nor address is present, email is required.

7. Starts With

Check if a string starts with a given value.

'username' => 'starts_with:admin,user',

The username must start with either admin or user.

8. Ends With

Similarly, check if a string ends with a specific value.

'username' => 'ends_with:_admin,_user',

The username must end with either _admin or _user.

9. In Array

Confirm a field’s value exists in another array field.

'selected_option' => 'in_array:available_options.*',

The selected_option must be one of the values in the available_options array.

10. Different

Make sure two fields have different values.

'new_password' => 'different:current_password',

The new_password must be different from the current_password.

Wrapping Up

So there you have it, folks! Ten super handy Laravel validation rules you might not have known about. Using these can save you time and make your code cleaner and more efficient.

All the above have been previously shared on our Twitter, one by one. Follow us on Twitter; You'll ❤️ it.

You can also check the first article of the series, which is on the Top 5 Scheduler Functions you might not know about. Keep exploring, and keep coding with ease using Laravel. Until next time, happy coding! 🚀

Laravel Caching - Explained Simply

Karan Datwani — Sat, 06 Jul 2024 17:47:54 +0000

Caching is like keeping your favorite toy right on top of your toy box, so you can grab it quickly whenever you want to play.

Similarly, cache in Laravel stores data so your website can show it quickly without searching or querying all over again. Just like finding your toy faster, caching helps websites load quickly.

How Does Caching Work in Laravel?

Laravel has a built-in storage called cache. It helps you store data and quickly get it later.

Storing Data in the Cache

For example - weather data. Weather won't change on every request, so why make a DB or API call every time? It would be way more efficient to keep the info handy in the cache:

$weatherData = getWeatherFromService();

Cache::put('current_weather', $weatherData, 60);

Here, current_weather is the cache key, $weatherData is the info, and 60 is the minutes to keep it.

Retrieving and Checking Data

To get weather data from the cache:

$weatherData = Cache::get('current_weather');

To check if the data is still there:

if (Cache::has('current_weather')) {
    // It's there!
}

Deleting Data from the Cache

To refresh weather data, remove old info:

Cache::forget('current_weather');

Cool Things You Can Do with Caching

For a busy blog or for an online shop, cache posts & products to boost speed:

use Illuminate\Support\Facades\Cache;

$blogPosts = Cache::remember('blog_posts', 30, function () {
    return DB::table('posts')->get();
});

$productList = Cache::remember('product_list', 10, function () {
    return Product::all();
});

Use Model events to setup cache automation, to keep cache data up to date. Example:

namespace App\Models;

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

class Post extends Model
{
    protected $fillable = ['title', 'content'];

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

        static::retrieved(function ($post) {
            Cache::remember("post_{$post->id}", 60, function () use ($post) {
                return $post;
            });
        });

        static::created(function ($post) {
            Cache::forget('all_posts');
            Cache::remember("post_{$post->id}", 60, function () use ($post) {
                return $post;
            });
        });

        static::updated(function ($post) {
            Cache::forget("post_{$post->id}");
            Cache::forget('all_posts');
            Cache::remember("post_{$post->id}", 60, function () use ($post) {
                return $post;
            });
        });

        static::deleted(function ($post) {
            Cache::forget("post_{$post->id}");
            Cache::forget('all_posts');
        });
    }

    public static function getAllPosts()
    {
        return Cache::remember('all_posts', 60, function () {
            return self::all();
        });
    }

    public static function searchPosts($query)
    {
        return Cache::remember("search_posts_{$query}", 60, function () use ($query) {
            return self::where('title', 'like', "%{$query}%")
                       ->orWhere('content', 'like', "%{$query}%")
                       ->get();
        });
    }
}

Wrapping Up

Caching in Laravel makes websites faster by storing data for quick access. Start using caching to speed up your Laravel app and make users happy!

All of the above have been previously shared on our Twitter, one by one. If you're on Twitter, follow us - you'll ❤️ it. You can also check the first article of the series, which is on the Top 5 Scheduler Functions you might not know about. Keep exploring, and keep coding with ease using Laravel. Until next time, happy caching! 🚀

Laravel Advanced: Top 5 Scheduler Functions You Might Not Know About

Karan Datwani — Mon, 17 Jun 2024 10:04:34 +0000

In this article series, we go a little deeper into parts of Laravel we all use, to uncover functions and features that we can use in our next projects... if only we knew about them! Our first article in the series is about the Laravel Scheduler - which helps run scheduled tasks (aka cron jobs).

Let's explore a few lesser-known scheduler functions:

1. skip() & when()

If you want your scheduled task to execute only when some condition is true, use when() to set such conditions inline:

$schedule->command('your:command')->when(function () {
    return some_condition();
});

skip() is the exact opposite of the when() method. If the skip method returns true, the scheduled task will not be executed:

$schedule->command('emails:send')->daily()->skip(function(){
    return Calendar::isHolidauy();
});

2. withoutOverlapping()

You may be running a critical job that should only have one instance running at a time. That's where withoutOverlapping() ensures that a scheduled task won't overlap, preventing potential conflicts.

$schedule->command('your:command')->withoutOverlapping();

3. thenPing()

After executing a task, you might want to ping a URL to notify another service or trigger another action. thenPing() lets you do just that seamlessly.

$schedule->command('your:command')->thenPing('http://example.com/webhook');

4. runInBackground()

If you want your scheduled task to run in the background without holding up other processes. runInBackground() will help you do this:

$schedule->command('your:command')->runInBackground();

5. evenInMaintenanceMode()

You can guess what it does by its name. You can execute scheduled tasks even when your application is in maintenance mode.

$schedule->command('your:command')->evenInMaintenanceMode();

That's all for now, folks! Give them a try; use these scheduler functions in your task automation and make your code much easier. All of the above have been previously shared on our Twitter, one by one. Follow us on Twitter; You'll ❤️ it.

Keep exploring, keep coding, and keep pushing the boundaries of what you can achieve with Laravel. Until next time, happy scheduling! 🚀

Top 10 Laravel Collection Methods You Have Never Used.

Karan Datwani — Sun, 09 Jun 2024 10:03:08 +0000

In this article series, we go a little deeper into parts of Laravel we all use, to uncover functions and features that we can use in our next projects... if only we knew about them!

Here are a few lesser-known collection methods that can be quite handy in various real-world scenarios:

macro(): This lets you add custom methods to Laravel collections that can be used on any collection instance:


use Illuminate\Support\Collection;

Collection::macro('customMethod', function () {
    // Your custom method logic
});

$collection = collect([...]);
// use on any collection object
$result = $collection->customMethod();

concat(): Suppose you have two collections of users from different sources and want to combine them into a single collection. You can use concat for this purpose:

$usersFromDatabase = User::where(...)->get();
$usersFromApi = collect([...]);

$combinedUsers = $usersFromDatabase->concat($usersFromApi);

pad(): You have a collection of tasks, but you want to ensure that it always contains a minimum number of elements. You can use pad to add dummy tasks if necessary:

$tasks = collect([...]);

$paddedTasks = $tasks->pad(10, 'Dummy Task');

shuffle() & random(): Suppose you have a quiz application and want to shuffle the order of the questions. You can use shuffle for this purpose. Additionally, if you're going to select a question from the collection randomly, you can use random:

$questions = collect([...]);

$shuffledQuestions = $questions->shuffle();
$randomQuestion = $questions->random();

crossJoin(): Suppose you've two collections and you want to generate all possible combinations from them.

$collection = collect([1, 2]); 
$matrix = $collection->crossJoin(['a', 'b']); 
$matrix->all();
/*[
    [1, 'a'],
    [1, 'b'],
    [2, 'a'],
    [2, 'b'],
]*/

$collection = collect([1, 2]); 
$matrix = $collection->crossJoin(['a', 'b'], ['I', 'II']); 
$matrix->all();
/*[
    [1, 'a', 'I'],
    [1, 'a', 'II'],
    [1, 'b', 'I'],
    [1, 'b', 'II'],
    [2, 'a', 'I'],
    [2, 'a', 'II'],
    [2, 'b', 'I'],
    [2, 'b', 'II'],
] */

partition(): Imagine you have a collection of students, and you want to partition them into two groups based on their grades (pass or fail). partition makes this easy:


$students = collect([...]);

list($passingStudents, $failingStudents) = $students->partition(function ($student) {

    return $student->grade >= 60;

});

first() and firstWhere(): You have a collection of tasks, and you want to retrieve the first task or the first task that meets certain criteria. first and firstWhere come in handy:


$tasks = collect([...]);

$firstTask = $tasks->first();

$urgentTask = $tasks->firstWhere('priority', 'urgent');

keyBy(): You have a collection of users, and you want to index them by their unique IDs for quick access. keyBy is the solution:


$users = collect([...]);

$indexedUsers = $users->keyBy('id');

filter(): You have a collection of orders coming from API and you want to filter out the canceled orders. The filter method is perfect for this:


$orders = collect([...]);

$validOrders = $orders->filter(function ($order) {

    return $order->status !== 'canceled';

});

transform(): You have a collection of tasks, and you want to modify each task in some way. transform allows you to apply a callback to each item to replace it:


$tasks = collect([...]);

$tasks->transform(function ($task) {

    return $task->name . ' - ' . $task->priority;

});

That's all for now, folks! These methods offer ease & flexibility that can be useful when working with Laravel applications.

All the above have been previously shared on our Twitter, one by one. Follow us on Twitter; You'll ❤️ it. You can also check the first article of the series, which is on Top 5 Scheduler Functions you might not know about. Keep exploring, keep coding, and keep pushing the boundaries of what you can achieve.

Laravel Advanced: Lesser-Known, Yet Useful Composer Commands

Karan Datwani — Sun, 02 Jun 2024 13:43:59 +0000

Composer is the go-to dependency manager for PHP, and if you're working with Laravel, you're already familiar with frequently used commands like composer install and composer update. Composer also offers some commands that are lesser-known but helpful while working on your Laravel app.

Here are five Composer commands you might not know but would love to use.

1. `composer outdated`

Ever wondered which of your app dependencies are outdated? composer outdated gives you a quick rundown of all packages that have newer versions available. This is especially useful for keeping your project up-to-date and secure.

composer outdated

This lists all the outdated packages in your project, showing the current and latest versions. It's a handy way to stay on top of updates without blindly running composer update.

2. `composer show`

Need an overview of the installed packages? The composer show displays information about all the packages installed in your project.

composer show

You can also use it to get details about a specific package by passing the package name:

composer show vendor/package
# Example: composer show backpack/crud

It’s a great way to quickly check the installed version, description, and dependencies of any package in your project.

3. `composer why`

Wanna figure out why a particular package is installed? composer why helps you trace the dependency tree to understand which package requires it.

composer why vendor/package

4. `composer licenses`

Wanna know the licenses of the packages you are using? composer licenses provides a summary of all the licenses of the installed dependencies. This is useful for ensuring compliance with open-source licenses.

composer licenses

5. `composer check-platform-reqs`

Checking all required PHP extensions are installed can be a hassle while working on a project across multiple environments. The composer check-platform-reqs command checks if your platform meets the package requirements.

composer check-platform-reqs

This command verifies that the PHP version and all required extensions are installed and meet the version constraints specified in your composer.json.

Conclusion

While basic Composer commands get the job done, these lesser-known commands can save you time and hassle by giving you deeper insights and more control over your project's dependencies. So, the next time you fire up your terminal, try these commands and see how they can improve your Laravel experience.

All of the above have been previously shared on our Twitter, one by one. Follow us on Twitter; You'll ❤️ it. You can also check the first article of the series, which is on the Top 5 Scheduler Functions you might not know about. Keep exploring, and keep coding with ease using Laravel. Until next time, happy composing! 🚀

DEV Community: Karan Datwani

4 Ways To Prevent Race Conditions in Laravel

Benefits of Preventing Race Conditions

Strategies to Prevent Race Conditions

1. Database Transactions

2. Pessimistic Locking

3. Optimistic Locking

4. Atomic Operations

Bonus Tip: Cache Locks

Final Word

🍣 Sushi — Your Eloquent model driver for other data sources

What is Laravel Sushi?

How to Use Sushi?

Example 1: Hardcoded Data

Example 2: Data from a Config Array

Example 3: Dynamic Data from an API with Caching

Why Use Sushi?

Conclusion

Backpack - Configure User Access Control and Permissions in 10 minutes

PermissionManager

Claiming Territory with Role & Permissions

Securing the Resources

Protecting Operations:

How to make this work for Custom Operations?

Protecting custom routes:

You may want to Spatie's directives like @role, @can

Conclusion

Make Your WebApp or Admin Panel Installable as a Mobile App

What Is a Progressive Web App (PWA)?

How to Make Your Web App Installable

Make Your Backpack AdminPanel Installable

Conclusion

Receive Slack Notifications from your Laravel App with a 10-minute Setup

Create a Slack App

Package Installation

Paste the Webhook & Oauth Token in your Laravel configuration.

Send Notifications

Use webhook URL in the packages.

Creating a Custom Notification

We can send the notification in two ways; Using Trait and Facade:

Get more out of Slack Notifications

Conclusion

Add Engaging Animations To Your Webapp for FREE

What is Lottie?

Getting Started

Adding Lottie Animations to Your Project

Wanna Embed into HTML or Wordpress?

Where is IOS, Android, React or Vue.. integration?

Conclusion

Top 10 PHP Features You Can Use in 2024

1. Readonly Properties

2. Enums

3. Match Expressions

4. Constructor Property Promotion

5. Named Arguments

6. Nullsafe Operator

7. Union Types

8. Array Unpacking with String Keys

9. JSON_THROW_ON_ERROR

10. JIT Compilation

Wrapping Up

Laravel Advanced: Top 10 Validation Rules You Didn't Know Existed

1. Prohibited

2. Prohibits

3. Required If

4. Required Unless

5. Required Without

6. Required Without All

7. Starts With

8. Ends With

9. In Array

10. Different

Wrapping Up

Laravel Caching - Explained Simply

How Does Caching Work in Laravel?

Storing Data in the Cache

Retrieving and Checking Data

Deleting Data from the Cache

Cool Things You Can Do with Caching

Wrapping Up

You may want to Spatie's directives like `@role`, `@can`

1. `composer outdated`

2. `composer show`

3. `composer why`

4. `composer licenses`

5. `composer check-platform-reqs`