How to use Repository Design Pattern in Laravel

The Repository Pattern is a technique for separating an application’s business logic from its data access layer. By developing a repository class in Laravel that has methods for managing data operations and using that repository class in your controllers rather than directly interacting with the model, you can implement the Repository Pattern.

Here is a simple example of how the Laravel Repository Pattern is used:

1. Create a repository interface that defines the methods you need to interact with your data.

interface PostRepositoryInterface
{
    public function all();
    public function find($id);
    public function create($data);
    public function update($id, $data);
    public function delete($id);
}

2. Create a concrete implementation of the repository interface.

class PostRepository implements PostRepositoryInterface
{
    protected $model;

    public function __construct(Post $model)
    {
        $this->model = $model;
    }

    public function all()
    {
        return $this->model->all();
    }

    public function find($id)
    {
        return $this->model->find($id);
    }

    public function create($data)
    {
        return $this->model->create($data);
    }

    public function update($id, $data)
    {
        $post = $this->model->find($id);
        $post->update($data);

        return $post;
    }

    public function delete($id)
    {
        return $this->model->find($id)->delete();
    }
}

3. Inject the repository into your controllers and use it instead of directly interacting with the model.

class PostsController extends Controller
{
    protected $repository;

    public function __construct(PostRepositoryInterface $repository)
    {
        $this->repository = $repository;
    }

    public function index()
    {
        $posts = $this->repository->all();

        return view('posts.index', compact('posts'));
    }

    public function show($id)
    {
        $post = $this->repository->find($id);

        return view('posts.show', compact('post'));
    }

    // ...
}

The implementation of the interface can be abstracted, extra methods can be added to your repository, or you can use a different design pattern to build on this simple illustration. To make it simpler to modify or test the implementation in the future, the data access layer will be separated from the other components of the program.