Laravel order by relation column with example

Some examples that demonstrate the usage of Laravel’s orderBy method with relationship columns, which can be applied in Laravel versions 5, 6, 7, 8, 9, and 10.

In this post, we focus on examples to use Laravel order by relation column. There are many different ways to achieve it.

Below are some examples that demonstrate the usage of Laravel‘s orderBy method with relationship columns. These examples can be applied in Laravel versions 5, 6, 7, 8, 9, and 10.

Example 1: Ordering by a BelongsTo Relationship Column

Consider the scenario where you have a "User" model that belongs to a "Role" model. You can use the orderBy method to sort the users based on the role name in ascending order.

$users = User::with(['role' => function ($q) {

You can use the same code for descending order by adding 'desc' argument to orderBy method as follows,

$users = User::with(['role' => function ($q) {
    $q->orderBy('name', 'desc');

For above example to work properly, you have to define belongsTo relationship of "Role" model inside the "User" model as follows,

public function role(): BelongsTo
    return $this->belongsTo(Role::class, 'role_id', 'id');

Example 2: Using inner join with relation table

For above scenario, where “User” model that belongs to “Role” model, you can use join method to perform user sorting based on role name as follows,

$users = User::select('*')
                 ->join('roles', 'users.role_id', '=', '')
                 ->orderBy('', 'asc');

As above example, you need to replace the second argument of orderBy method to 'desc' for sort records in descending order. There is no need of any relationship required for this query.

Example 3: Using sortBy() and sortByDesc() methods

You can use sortBy() and sortByDesc() methods to order the records for the same scenario as follows,

$users = User::get()->sortBy(function($query){
    return $query->role->name;

In above example, it first get the users collection from the database and then sort them by the provided relation column. For these methods, you have to define belongsTo relationship in "User" model.

You can use sortByDesc() method same as above.

Example 4: Using subquery and whereColumn method

You can also use subqueries to sort records. For the above scenario, you can use subqueries as follows,

$users = User::select('*')
        ->whereColumn('', 'users.role_id')

In above example, we have we used subquery from roles table using whereColumn method to get the name of the role of each row of users table. After getting the role name, we used orderBy method to achieve the sorted records.

For sorting records in descending order, you can use the above example with orderByDesc method.

You can use this example, without defining belongsTo relationship in model.

These are some useful examples to order records based on relationship model in Laravel.

Learn How to Use Laravel Enum Casting

Laravel 9 has introduced enum model attribute casting, which makes it easier than ever to use enums in your application. With the help of an enum class and model casting, you can easily set up your table with specific enum values.

If you’re looking to use the enum data type in Laravel, you can do so easily with the help of enum model attribute casting. In this post, we’ll walk you through a step-by-step example to show you how to use enums in Laravel and cast them to a model attribute.

First, you’ll need to create a migration with a string column called "status" and a default value of "pending". Then, you can create a model and set the cast to your enum class. With this approach, you won’t have to create a new migration every time you want to add a new enum value to your table.

Laravel 9 has introduced enum model attribute casting, which makes it easier than ever to use enums in your application. With the help of an enum class and model casting, you can easily set up your table with specific enum values.

In this example, we’ll guide you through the process of creating a migration with a string column, creating a model with a cast to your enum class, and creating an enum class with specific values. Follow along with our step-by-step example to learn how to use Laravel enum attribute casting today.

Step 1: Install Laravel

If you haven’t already created a Laravel app, run the following command to install Laravel:

composer create-project laravel/laravel example-app

It will install new laravel app inside example-app folder. For further commands, go inside the example-app folder. There are many other ways to install the laravel application. Click on this link to visit Laravel installation documentation.

Step 2: Create Laravel Migration

Create a migration for the "enquiries" table with name, email, phone and status columns, as well as a model for the enquiries table. run the following command to create migration:

php artisan make:migration create_enquiries_table

Update the migration file with the following code:

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

return new class extends Migration
    public function up()
        Schema::create('enquiries', function (Blueprint $table) {

    public function down()

Now, we are ready with our migration script. Run the following command to create the "enquiries" table:

php artisan migrate

Note that, we created the table with "status" value as "pending" by default.

Step 3: Create Enum Class

Create the Enums folder and EnquiryStatusEnum.php class inside the Enums to define all enum values as follows:

namespace App\Enums;

enum EnquiryStatusEnum: string {
    case Pending = 'pending';
    case InProgress = 'in-progress';
    case Closed = 'closed';

Step 4: Create Model

Now, we need a model file for our enquiries table. To create a model, run the following command:

php artisan make:model Enquiry

It will create Enquiry.php file inside the app/Models folder. Change the model file as follows:

namespace App\Models;

use Illuminate\Database\Eloquent\Factories\HasFactory;
use Illuminate\Database\Eloquent\Model;
use App\Enums\EnquiryStatusEnum;

class Enquiry extends Model
    use HasFactory;

    protected $fillable = [
        'name', 'email', 'phone', 'status'

    protected $casts = [
        'status' => EnquiryStatusEnum::class

Here, we defined a $casts variable, which will cast the status variable with EnquiryStatusEnum class.

Step 5: Create Controller

Now, create a controller file using the following command:

php artisan make:controller EnquiryController

It will create the EnquiryController.php file inside the app/Http/Controllers folder. Write the following code inside index() method to create item records with an array and access as an array:

namespace App\Http\Controllers;

use Illuminate\Http\Request;
use App\Models\Enquiry;
use App\Enums\EnquiryStatusEnum;

class EnquiryController extends Controller
    public function index()
        $input = [
            'name' => 'Test User',
            'email' => '',
            'phone' => 6358465465
            'status' => EnquiryStatusEnum::Active

        $enquiry = Enquiry::create($input);

        dd($enquiry->status, $enquiry->status->value);

In above code, we have added a new entry inside the enquiries table and right after that we displayed the enquiry status.

Step 6: Create Route

To create a route for testing our code, add the following lines to routes/web.php file:

use Illuminate\Support\Facades\Route;
use App\Http\Controllers\EnquiryController;

Route::get('enquiry', [EnquiryController::class, 'index']);

Step 7: Run the Laravel app

To run the laravel app, use the following command:

php artisan serve

Open your web browser and enter the following URL to view the app output:


You can see the database output and print variable output:

App\Enums\EnquiryStatusEnum {#1781
    name: "InProgress"
    value: "in-progress"


You can see the database output, which is showing casted values from EnquiryStatusEnum. And second parameter is value output, which is showing it’s corresponding string value "in-progress".

With these simple steps, you can easily use enum in Laravel without the need for constant migrations.

Install React JS with Laravel Breeze

Install Laravel Breeze, which offers React JS scaffolding via an Inertia frontend implementation to build modern React JS app.

In this React JS tutorial, we learn to install Laravel Breeze with React JS over Laravel Application. Laravel Breeze come equipped with out-of-the-box scaffolding for new Inertia applications, making them the quickest and easiest way to get your Inertia project off the ground with React Js.

For this post, we are using Laravel Breeze. This minimal implementation includes login, registration, password reset, email verification, password confirmation, and a basic “profile” page for updating user information.

Laravel Breeze comes equipped with simple Blade templates styled with Tailwind CSS. However, if you prefer to scaffold your application using React JS and Inertia JS, Laravel Breeze can do that too.

In addition to being an excellent starting point for a new Laravel project, Laravel Breeze is also a great choice for projects that want to elevate their Blade templates using Laravel Livewire.

Install laravel project and setup database

First install a fresh new Laravel application from the composer using the following command,

composer create-project laravel/laravel inertia-react

It will create the laravel project folder named inertia-react .

Now, you have to connect the laravel app to the database. Go inside this folder and open .env to change the database connection details as follows,


After changing the connection details, run all migrations for the project using the following command,

php artisan migrate

Install Laravel Breeze over Laravel

Once you ready with the Laravel installation, you can proceed with Laravel Breeze installation using Composer using the following command,

composer require laravel/breeze --dev

Once you’ve installed the Laravel Breeze package using Composer, it’s time to run the breeze:install Artisan command as follows,

php artisan breeze:install

This command will publish all the necessary authentication resources, including views, routes, controllers, and more, directly to your application.

Laravel Breeze publishes its code directly to your application, giving you complete control and visibility over its features and implementation. This allows you to easily customize and tailor the authentication experience to fit your unique needs.

If you want to use an Inertia stack with React JS in your Laravel Breeze application, simply specify “react” as your desired stack when running the breeze:install Artisan command as follows,

php artisan breeze:install -react

Once the scaffolding is installed, be sure to compile your application’s frontend assets to ensure proper functionality:

npm install && npm run dev

With the initial setup complete, it’s time to test your application’s authentication functionality. Simply navigate to the /login or /register URLs in your web browser to get started.

All of Laravel Breeze‘s routes are defined in the routes/auth.php file, making it easy to modify or customize the authentication routes as needed.

How to upload file code using Laravel

To upload a file using Laravel, you can follow these steps:

Create a new form in your Laravel view with an input field for the file:

<form method="POST" action="{{ route('file.upload') }}" enctype="multipart/form-data">

    <input type="file" name="file">

    <button type="submit">Upload</button>

Define a new route in your routes/web.php file that points to a controller method that will handle the file upload:

Route::post('/file/upload', [App\Http\Controllers\FileController::class, 'upload'])->name('file.upload');

Create a new controller method in FileController that will handle the file upload:

public function upload(Request $request)
    // Validate the uploaded file
        'file' => 'required|file|max:1024', // limit file size to 1 MB

    // Store the uploaded file in the storage/app/public directory
    $path = $request->file('file')->store('public');

    // Generate a URL for the uploaded file
    $url = Storage::url($path);

    // Redirect back with a success message
    return back()->with('success', 'File uploaded successfully: ' . $url);

In the upload() method, we first validate that the uploaded file meets our requirements (in this case, it must be a file and not exceed 1 MB in size). We then use the store() method on the uploaded file to store it in the storage/app/public directory. This directory is publicly accessible, so we can generate a URL for the file using the url() method on the Storage facade. Finally, we redirect back to the form with a success message that includes the URL of the uploaded file.

You can now test the file upload functionality by navigating to the form and selecting a file to upload. If the file meets the validation requirements, it will be uploaded and a success message will be displayed. You can then access the uploaded file at the generated URL.

What is Middleware and how to create one in Laravel?

It’s best to envision middleware as a series of “layers” for HTTP requests that must pass through before they hit your application. Each layer can examine the request and even reject it entirely.

Middleware provides a convenient mechanism for inspecting and filtering HTTP requests entering your application. It’s best to envision middleware as a series of “layers” for HTTP requests that must pass through before they hit your application. Each layer can examine the request and even reject it entirely.

For example, Laravel includes a middleware that verifies the authenticity of the user of your application. If the user is not authenticated, the middleware will redirect the user to your application’s login screen. However, if the user is authenticated, the middleware will allow the request to proceed further into the application.

To perform different tasks, we can develop many middlewares besides authentication. For example, a logging middleware might log all incoming requests to your application. 

Laravel framework has included many middlewares, including middleware for authentication and CSRF protection. All of these middlewares are located in the app/Http/Middleware directory.

To create a middleware, we can use the following command,

php artisan make:middleware <middleware-name>

For example, if we want to create a middleware for checking transactions, we can run the following command,

php artisan make:middleware CheckTransaction

 After successful execution of the command, a middleware class will be created under the app/Http/Middleware directory.

In this class, we can define methods to check transactions. If the transaction is not completed, we can redirect the user back to the failed transaction page. However, on the successful transactions, we can allow users to proceed to the next page.

namespace App\Http\Middleware;
use Closure;
class CheckTransaction
     * Handle an incoming request.
     * @param  \Illuminate\Http\Request  $request
     * @param  \Closure  $next
     * @return mixed
    public function handle($request, Closure $next)
        if ($request->input('status') !== 'completed') {
            return redirect('transaction-failed');
        return $next($request);

As you can see, if the transaction status does not set to “completed”, the middleware will return an HTTP redirect to the client; otherwise, the request will be passed further into the application.

To pass the request deeper into the application (allowing the middleware to “pass”), you should call the $next callback with the $request.