How to Use the Repository Pattern in Laravel Project?

The Repository Pattern is essential for building scalable and maintainable Laravel websites. It separates data access logic from business logic, ensuring cleaner code, better organization, and easier testing. By promoting reusability and efficient queries, it simplifies switching databases and integrating APIs in Laravel projects.

In this blog, we’ll cover everything you need to implement the Repository Pattern. You’ll learn about the prerequisites and how you can use the Laravel Repository Pattern in your project. Additionally, we’ll dive into the best practices expert Laravel developers follow when implementing Repository Patterns. With that said, let’s begin by understanding what a Repository Pattern is.

What is the Repository Pattern in Laravel?

The Repository Pattern in Laravel is a design pattern that acts as a bridge between the business logic and the data access layer (like Eloquent models). Its primary goal is to abstract and encapsulate database operations into a separate class. That improves the modularity, reusability, and testability of code.

Instead of directly querying models in controllers, the Repository Pattern enables developers to interact with a well-defined interface. That makes the code more maintainable and easier to change or extend in the future.

Prerequisites

Before implementing the Repository Pattern in a Laravel project, you’ll need some prerequisite tools and setups to ensure a smooth workflow. Here’s what’s required:

• PHP 7.4 or above
• Composer installed globally
• Access to a MySQL database

By ensuring these tools in place, you can begin to set up and implement the Repository Pattern in a Laravel project.

How to Use the Repository Pattern in a Laravel Project?

To implement the Repository Pattern in a Laravel, you need to decouple your controllers from models and database interactions. Here is a stepwise process you can follow to implement Repository Pattern in Laravel:

Step 1: Create a New Laravel Project

To begin, you need to set up a new Laravel project. This can be done using Composer, a dependency manager for PHP.

composer create-project --prefer-dist laravel/laravel repository-pattern-example
cd repository-pattern-example

This command creates a new Laravel project in a directory called repository-pattern-example. Ensure that you have Composer and PHP installed on your machine as mentioned earlier.

Step 2: Set Up Database Configuration

Next, configure your database connection in the .env file. Laravel supports various database systems, so choose one that suits your needs (e.g., MySQL, SQLite, PostgreSQL). To configure the database, open the .env file in your project and set the following database credentials:

DB_CONNECTION=mysql
DB_HOST=127.0.0.1
DB_PORT=3306
DB_DATABASE=your_database_name
DB_USERNAME=your_username
DB_PASSWORD=your_password

With that. we’ve set the database connection parameters, which Laravel will use to connect to your database for CRUD operations.

Step 3: Create a Model and Migration

Create a model that represents the data you will be working with. Along with the model, generate a migration file to define the structure of your database table.

php artisan make:model Product -m

This command creates a Product model and a migration file for the products table. You can define the fields in the migration file located in database/migrations.

Step 4: Define the Migration

Open the migration file and define the schema for the products table. This step is crucial as it sets up the actual database structure. Here is the code you may add to the migration file:

public function up()
{
    Schema::create('products', function (Blueprint $table) {
        $table->id();
        $table->string('name');
        $table->decimal('price', 8, 2);
        $table->timestamps();
    });
}

Here, we’ve defined the schema for the products table with fields id, name, price, and timestamp fields. The next step will be to run this migration to create the table.

Step 5: Run the Migration

Now, you need to perform the migration to create the products table in your database.

php artisan migrate

This command runs the migration, creating the products table in your database as per the defined schema.

Step 6: Create the Repository Interface

Define a repository interface that specifies the methods you will implement in your repository. This promotes consistency and allows for easier testing. Here is interface code you add by creating a new file in app/Repositories named ProductRepositoryInterface.php.

namespace App\Repositories;
interface ProductRepositoryInterface
{
    public function all();
    public function find($id);
    public function create(array $data);
    public function update($id, array $data);
    public function delete($id);
}

This interface defines the structure of the repository, specifying CRUD methods to be implemented by the repository class.

Step 7: Create the Repository Class

Implement the repository interface in a concrete class. This class will handle the actual data logic. To do so create a new file in app/Repositories named ProductRepository.php. After that add the following code to ProductRepository.php you created:

namespace App\Repositories;
use App\Models\Product;
class ProductRepository implements ProductRepositoryInterface
{
    public function all()
    {
        return Product::all();
    }
    public function find($id)
    {
        return Product::find($id);
    }
    public function create(array $data)
    {
        return Product::create($data);
    }
    public function update($id, array $data)
    {
        $product = Product::find($id);
        $product->update($data);
        return $product;
    }
    public function delete($id)
    {
        return Product::destroy($id);
    }
}

You’ve created the ProductRepository class that implements the methods defined in the interface, each handling a specific CRUD operation on Product data.

Step 8: Register the Repository in a Service Provider

To use dependency injection, bind the interface to the implementation in a service provider. Open app/Providers/AppServiceProvider.php and register the binding in the register method. Here is the code you can add to AppServiceProvider.php file:

use App\Repositories\ProductRepositoryInterface;
use App\Repositories\ProductRepository;
public function register()
{
    $this->app->bind(ProductRepositoryInterface::class, ProductRepository::class);
}

This binding tells Laravel to resolve ProductRepositoryInterface with ProductRepository when the interface is requested. That allows dependency injection to work seamlessly.

Step 9: Use the Repository in a Controller

Now, create a controller that will utilize the repository to perform actions. This keeps your controller clean and focused on handling HTTP requests. To generate a controller use the command:

php artisan make:controller ProductController

In ProductController, use dependency injection to inject ProductRepositoryInterface and handle product data:

namespace App\Http\Controllers;
use App\Repositories\ProductRepositoryInterface;
use Illuminate\Http\Request;
class ProductController extends Controller
{
    protected $productRepo;
    public function __construct(ProductRepositoryInterface $productRepo)
    {
        $this->productRepo = $productRepo;
    }
    public function index()
    {
        $products = $this->productRepo->all();
        return response()->json($products);
    }
    // Additional methods for create, update, and delete can be added similarly
}

Here, we’ve created a ProductController that injects the ProductRepositoryInterface and uses it to fetch products. This promotes a clean separation of concerns.

Step 10: Define Routes

Finally, set up routes to access the controller methods you just created. Add the below code in routes/web.php:

use App\Http\Controllers\ProductController;
Route::get('/products', [ProductController::class, 'index']);

With that, we’ve defined a route that maps a GET request to the /products endpoint, which will call the index method in ProductController.

Step 11: Write a Test for the Repository

To ensure that your repository works as expected, write a test case using Laravel’s built-in testing framework. First, create a test file named ProductRepositoryTest.php in tests/Feature/ folder using the command:

create a php artisan make:test ProductRepositoryTest

Then write the test code for the repository you created in the ProductRepositoryTest.php file:

namespace Tests\Feature;
use App\Models\Product;
use App\Repositories\ProductRepository;
use Illuminate\Foundation\Testing\RefreshDatabase;
use Tests\TestCase;
class ProductRepositoryTest extends TestCase
{
    use RefreshDatabase;
    protected $productRepo;
    protected function setUp(): void
    {
        parent::setUp();
        $this->productRepo = new ProductRepository();
    }
    public function test_create_product()
    {
        $data = ['name' => 'Test Product', 'price' => 99.99];
        $product = $this->productRepo->create($data);
        $this->assertInstanceOf(Product::class, $product);
        $this->assertDatabaseHas('products', $data);
    }
    public function test_get_all_products()
    {
        Product::factory()->count(3)->create();
        $products = $this->productRepo->all();
        $this->assertCount(3, $products);
    }
}

Here, we’ve created a test to verify that the ProductRepository can create a product and retrieve all products. It uses RefreshDatabase to ensure a clean state between tests. To run the test use the artisan command:

php artisan test

This command executes the test we have written. If everything is correctly implemented, the tests will pass, confirming your repository works as expected.

With that we’ve successfully implemented the Repository Pattern in your Laravel website. This approach promotes cleaner code organization, making your website more maintainable and testable. Now let’s dive into the best practices professional Laravel developers follow while using Repository patterns.

Best Practices for Using the Repository Pattern in Laravel

Implementing the Repository Pattern in Laravel can improve the scalability and testability of your codebase. Here are some best practices for using the Repository pattern effectively in Laravel:

• Use Interfaces for Repositories: Every repository should have its own interface. This ensures loose coupling between the repository and the application logic. Using interfaces also makes it easier to swap implementations (e.g., switching from Eloquent to MongoDB) without changing the backend logic code.
• Inject Dependencies via Constructor: Apply dependency injection by injecting the repository interfaces into controllers or services instead of directly creating them using new. This approach improves testability and follows Laravel’s dependency injection practices.
• Organize Logic Between Base and Child Repositories: Common database operations (like all(), find(), and delete()) should be moved to a BaseRepository to avoid code duplication. Child repositories should focus on model-specific logic to adhere to the Single Responsibility Principle (SRP).
• Avoid Static Methods: It is recommended to inject the model into the repository class through the constructor instead of using static methods. That makes it easier to mock models during unit testing and keeps the code more readable.
• Follow DRY Principles: Ensure that shared logic across multiple repositories is abstracted into a common class (such as BaseRepository). That helps maintain cleaner code and prevents redundancy.

By following these best practices, you can maximize the benefits of using the Repository pattern in Laravel projects. If you are looking to build a scalable and secured website with the best practices followed, hire Laravel development services.

FAQs About Using Laravel Repository Pattern

Wrapping Up

The Repository Pattern improves the Laravel website by organizing code and separating business logic from data access. To implement Repositories Pattern in Laravel you can begin with configuring and creating data tables.

After that, you can create the repository interface and register it with the service provider. Once it’s all done, you can define the routes and test your site by writing a testing code according to your site. While performing these steps, ensure that best practices are followed to maximize the benefit of the Repository Pattern.

If you are looking to create a site that is robust, scalable, and well-designed, hire Laravel developers.