Download the PHP package duardaum/laravel-repository without Composer

Laravel Repository

A simple Repository and Service layer for Laravel and Lumen Applications.

Features

• Clean separation of data access logic using the Repository Pattern.
• Easily customizable repositories and interfaces.
• Built-in support for soft deletes and query context (active, trashed, or both).
• Simple integration with Laravel/Lumen's Service Container.
• Extendable base repository with common CRUD and other operations.

Summary

• Compatibility
• Features
• Installation
• Configuration
• Usage
  • Models, Repositories and Interfaces
  • Basic Usage
  • Create, Update and Delete
  • Create via CSV file (import file)
  • Read
  • Custom Methods
  • Available Methods
• Testing
• Contributing
• License

Compatibility

Installation

Use composer to install the package:

Configuration

In your Laravel/Lumen application, create a new Service Provider.
This Service Provider will be the place where you'll register all your Repositories.
You can register your repositories in the AppServiceProvider if you wish, but to keep things separated and for the possibility the Service Provider be very large, we recommend putting them separated.

And then, register the new Service Provider in your application:

On Lumen:

On Laravel:

Usage

The Repository Pattern is a design pattern that became very popular over the years.
It's a very nice and good way to organize data access and logic in one place, keeping other parts of your application responsible for what they do best,
especially if you are using other Design Patterns like S.O.L.I.D and Clean Code.
With this in mind, we created this very simple but yet powerful package, for you to centralize all your data access in a very simple way.

Model, Repository & Interface

Let's suppose that we have a table called messages with this structure, and we'll run some SQL commands on it:

First, let's create a Model:

Then, let's create an Interface for the Repository. All interfaces MUST extend from BaseRepositoryInterface:

And let's create the Repository. All repositories MUST extend from BaseRepository and implement an interface that was extended from BaseRepositoryInterface.
For the repository to know what table it should run the queries on, we need to inform a Model for the Repository:

P.S.: Some people do not like to use Interfaces on repositories. If it's your case, just dont and all be fine too!

Finally, let's register the repository to be used in the application:

This structure with Repository & Interface is very helpful if you need to make a different implementation of the same repository.
The contract of the repository stays the same and does not affect your application, needing to go in one place to replace all.

Basic usage

You can inject the Interface in constructors/methods to instantiate the Repository or use the Service Container to do it:

Create, Update and Delete

To make these operations is very simple:

Create via CSV file (import file)

One of the common challange we face in our day-in-day work, is importing a large number of register via CSV files to the database. \ Some time, we dont need nothing fancy, just a simple but yet powerfull way to import the file, where we can customize witch column on CSV file we want to import for certain table column. \ Thinking of that, we create an opinionated way to do this kind of work in a simple, fast and using the minimum amount of memory possible.

This type of task can be done in several ways, but the way your environment is configured and the resources are available will influence performance!

For this task, we create the importFile method on the BaseRepository, that has 4 parameters:

• (string) $path: Path to the CSV file
• (array) $columns: The To (table) / From (file) columns
• (?callable) $rowGenerate: A callable to format a row to insert on table
• (null|stdClass|array) $options: A setup options to import the file
  • $options->separator (string): PHP fgetcsv separator's. Default comma!
  • $options->chunkSize (int): The size of chunk of data to be insert at once per time. Default and max 1000!
  • $options->hasHeader (bool): If the file has header (first line have column names). Default false!

The method return the number of chunk inserted on database!

Import: Basic (no $rowGenerate)

Import: Advanced (with $rowGenerate)

For more example, look into our test suite!

Read

One of the greatest features of this package is the possibility to read data from different states (active, deactivated or both) in the same operation with minimal effort. By default, the repository will get data only for active records (newQuery). To get from trash (deactivated) or both, there is an easy way to do it:

Custom methods

To create a custom method on repository is very simple, and you can take advantage of the built-in methods of the base repository to do it:

And you can create a custom method, taking into consideration the query context chosen by user:

Available Methods

The BaseRepository provides sereval methods out of the box that you can use easily like:

• getTableName(): Get the table name
• deleteWhere(array $where): Soft delete records by condition
• forceDeleteWhere(array $where): Force delete records by condition
• restoreWhere(array $where): Restore soft deleted records by condition
• findWhereLimit(array $where, int $limit = self::DEFAULT_PAGINATOR_LIMIT, array $columns = ['*']): Search a limited number of records by condition
• findWherePaginate(array $where, int $perPage = self::DEFAULT_PAGINATOR_LIMIT, array $columns = ['*'], string $pageName = null, int $page = null): Search for records and page the result

You can extend your repository with custom methods as needed. For more available methods, you can find here . \ Yet, you can use the Eloquent methods strait from repository if you need to via the builder method:

You can see how to use all methods looking in our tests .

Testing

To ensure your repositories are working as expected, you can write tests using Laravel's built-in testing tools. Example:

Contributing

Pull requests are welcome! For major changes, please open an issue first to discuss what you would like to change.

How to contribute:

1. Fork the repository.
2. Create your feature branch (git checkout -b feature/your-feature).
3. Commit your changes (git commit -am 'Add some feature').
4. Push to the branch (git push origin feature/your-feature).
5. Open a pull request.

Please make sure to update tests as appropriate.

License

MIT