DEV Community: Joton Sutradhar

Creating A Laravel CRUD Application With The Repository Pattern

Joton Sutradhar — Sat, 01 Feb 2025 14:19:24 +0000

Laravel is a powerful PHP framework that simplifies web application development. When building a CRUD (Create, Read, Update, Delete) application, using the Repository Pattern can make your code cleaner, more maintainable, and easier to test. In this blog, we'll guide you through setting up a Laravel project with the Repository Pattern for a CRUD operation.

Project Structure

laravel-crud-repository/
│── app/
│   ├── Http/
│   │   ├── Controllers/
│   │   │   ├── ProductController.php
│   ├── Models/
│   │   ├── Product.php
│   ├── Providers/
│   │   ├── RepositoryServiceProvider.php
│   ├── Repositories/
│   │   ├── Interfaces/
│   │   │   ├── ProductRepositoryInterface.php
│   │   ├── Eloquent/
│   │   │   ├── ProductRepository.php
│── database/
│   ├── migrations/
│   │   ├── xxxx_xx_xx_create_products_table.php
│── routes/
│   ├── api.php
│── .env
│── composer.json
│── artisan

Step 1: Install Laravel

If you haven't installed Laravel yet, run the following command to create a new Laravel project:

composer create-project laravel/laravel laravel-crud-repository
cd laravel-crud-repository

Step 2: Configure Database

Update your .env file with your database credentials:

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

Run migrations to set up the database:

php artisan migrate

Step 3: Create a Model and Migration

Generate a model with migration for a sample entity, like Product:

php artisan make:model Product -m

Modify the migration file in database/migrations/xxxx_xx_xx_xxxxxx_create_products_table.php:

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

Run the migration:

php artisan migrate

Step 4: Implement the Repository Pattern

1. Create the Interface in Interfaces Folder

Create a new folder app/Repositories/Interfaces/ and then the ProductRepositoryInterface.php file:

namespace App\Repositories\Interfaces;

interface ProductRepositoryInterface
{
    public function getAll();
    public function getById($id);
    public function create(array $data);
    public function update($id, array $data);
    public function delete($id);
}

2. Implement the Repository in the Eloquent Folder

Create the Eloquent folder inside Repositories/ and create ProductRepository.php:

namespace App\Repositories\Eloquent;

use App\Models\Product;
use App\Repositories\Interfaces\ProductRepositoryInterface;

class ProductRepository implements ProductRepositoryInterface
{
    public function getAll()
    {
        return Product::all();
    }

    public function getById($id)
    {
        return Product::findOrFail($id);
    }

    public function create(array $data)
    {
        return Product::create($data);
    }

    public function update($id, array $data)
    {
        $product = Product::findOrFail($id);
        $product->update($data);
        return $product;
    }

    public function delete($id)
    {
        return Product::destroy($id);
    }
}

3. Bind the Repository in the Service Provider

Run:

php artisan make:provider RepositoryServiceProvider

Modify app/Providers/RepositoryServiceProvider.php:

namespace App\Providers;

use Illuminate\Support\ServiceProvider;
use App\Repositories\Interfaces\ProductRepositoryInterface;
use App\Repositories\Eloquent\ProductRepository;

class RepositoryServiceProvider extends ServiceProvider
{
    public function register()
    {
        $this->app->bind(ProductRepositoryInterface::class, ProductRepository::class);
    }
}

App\Providers\RepositoryServiceProvider::class,

Step 5: Create a Controller and Inject the Repository

Modify app/Http/Controllers/ProductController.php:

namespace App\Http\Controllers;

use App\Repositories\Interfaces\ProductRepositoryInterface;
use Illuminate\Http\Request;

class ProductController extends Controller
{
    protected $productRepository;

    public function __construct(ProductRepositoryInterface $productRepository)
    {
        $this->productRepository = $productRepository;
    }

    public function index()
    {
        return response()->json($this->productRepository->getAll());
    }

    public function store(Request $request)
    {
        $data = $request->validate([
            'name' => 'required|string|max:255',
            'description' => 'nullable|string',
            'price' => 'required|numeric',
        ]);

        return response()->json($this->productRepository->create($data));
    }

    public function show($id)
    {
        return response()->json($this->productRepository->getById($id));
    }

    public function update(Request $request, $id)
    {
        $data = $request->validate([
            'name' => 'sometimes|string|max:255',
            'description' => 'nullable|string',
            'price' => 'sometimes|numeric',
        ]);

        return response()->json($this->productRepository->update($id, $data));
    }

    public function destroy($id)
    {
        return response()->json(['deleted' => $this->productRepository->delete($id)]);
    }
}

Step 6: Define API Routes

Modify routes/api.php:

use App\Http\Controllers\ProductController;

Route::apiResource('products', ProductController::class);

Step 7: Test the API

Run the Laravel development server:

php artisan serve

Test using Postman or cURL:

Get all products:

curl -X GET http://127.0.0.1:8000/api/products

Create a product:

curl -X POST -H "Content-Type: application/json" \
  -d '{"name": "Laptop", "description": "A gaming laptop", "price": 1500}' \
  http://127.0.0.1:8000/api/products

Final Thoughts

By organizing repositories into separate Interfaces and Eloquent folders, this approach makes your Laravel project more scalable and structured. This Repository Pattern ensures loose coupling, making it easier to switch to a different data source in the future.

Now you have a Laravel project following the Repository Pattern for CRUD operations! 🚀 Let me know if you have any questions!

Checkout my portfolio here
Joton Sutradhar

Check changes with isDirty() & getChanges() in Laravel Eloquent Model

Joton Sutradhar — Wed, 20 Dec 2023 05:45:53 +0000

Before diving into isDirty() & getChanges(), let's have some brief about Laravel Eloquent Model.

Laravel Eloquent Model

Laravel includes Eloquent, an object-relational mapper (ORM) that makes it enjoyable to interact with a database. When using Eloquent, each database table has a corresponding "Model" that is used to interact with that table. In addition to retrieving records from the database table, Eloquent models allow you to insert, update, and delete records from the table as well. To see more, checkout Laravel Eloquent.

isDirty()

The isDirty() is used BEFORE save, to see what attributes were changed between the time when it was retrieved from the database and the time of the call. If there is any change the isDirty() method will return true.

/**
* Determine if the model or any of the given attribute(s) have been modified.
*
* @param  array|string|null  $attributes
* @return bool
*/
public function isDirty($attributes = null)
{
    return $this->hasChanges(
       $this->getDirty(), is_array($attributes) ? $attributes : func_get_args()
    );
}

/**
* Determine if any of the given attributes were changed.
*
* @param  array  $changes
* @param  array|string|null  $attributes
* @return bool
*/
protected function hasChanges($changes, $attributes = null) {
   // If no specific attributes were provided, we will just see if the dirty array
   // already contains any attributes. If it does we will just return that this
   // count is greater than zero. Else, we need to check specific attributes.
   if (empty($attributes)) {
       return count($changes) > 0;
   }

   // Here we will spin through every attribute and see if this is in the array of
   // dirty attributes. If it is, we will return true and if we make it through
   // all of the attributes for the entire array we will return false at end.
   foreach (Arr::wrap($attributes) as $attribute) {
       if (array_key_exists($attribute, $changes)) {
           return true;
       }
   }


   return false;
}

getChanges()

The getChanges() is used AFTER save, to see that attributes were changed/updated in the last save. Eloquent models have two protected arrays, $original and $changes, which contain the attributes as they were when fetched from storage and the attrbirutes which have been modified, respectively. The getChanges() method returns the modified changes.

/**
* Get the attributes that were changed.
*
* @return array
 */
public function getChanges()
{
   return $this->changes;
}

To get more details checkout this!

Example

let's have an example of isDirty() & getChanges().

// Fetch user data from User model
$user = User::findOrFail(1);
$user->name = "Updated Name";
$user->email = "updated@email.com";

// check the model has changed
if ($user->isDirty()) {
    $user->save();
}

// check the model attribute has changed
if ($user->isDirty('email')) {
    $user->save();
}

// wasChanged() is a boolean indicating if the model was modified during the current request lifecycle.
if (!$user->wasChanged()) {
   $changes = $user->getChanges();
}

Conclusion

In summary, isDirty() & getChanges() methods help you to track and manage the changes in Eloquent Model. Xdddddd teda🤓.