recca0120 / laravel-repository by recca0120

Repository for Laravel 5
37,094
129
5
Package Data
Maintainer Username: recca0120
Maintainer Contact: recca0120@gmail.com (recca0120)
Package Create Date: 2016-06-03
Package Last Update: 2024-02-26
Home Page:
Language: PHP
License: MIT
Last Refreshed: 2024-03-23 03:07:44
Package Statistics
Total Downloads: 37,094
Monthly Downloads: 943
Daily Downloads: 16
Total Stars: 129
Total Watchers: 5
Total Forks: 24
Total Open Issues: 3

Repository Design Pattern for Laravel

StyleCI Build Status Total Downloads Latest Stable Version Latest Unstable Version License Monthly Downloads Daily Downloads Scrutinizer Code Quality Code Coverage

Install

To get the latest version of Laravel Exceptions, simply require the project using Composer:

composer require recca0120/repository

Instead, you may of course manually update your require block and run composer update if you so choose:

{
    "require": {
        "recca0120/repository": "~2.0.0"
    }
}

Methods

Recca0120\Repository\EloquentRepository

  • find($id, $columns = ['*']);
  • findMany($ids, $columns = ['*']);
  • findOrFail($id, $columns = ['*']);
  • findOrNew($id, $columns = ['*']);
  • firstOrNew(array $attributes, array $values = []);
  • firstOrCreate(array $attributes, array $values = []);
  • updateOrCreate(array $attributes, array $values = []);
  • firstOrFail($criteria = [], $columns = ['*']);
  • create($attributes);
  • forceCreate($attributes);
  • update($id, $attributes);
  • forceUpdate($id, $attributes);
  • delete($id);
  • forceDelete($id);
  • newInstance($attributes = [], $exists = false);
  • get($criteria = [], $columns = ['*']);
  • chunk($criteria, $count, callable $callback);
  • each($criteria, callable $callback, $count = 1000);
  • first($criteria = [], $columns = ['*']);
  • paginate($criteria = [], $perPage = null, $columns = ['*'], $pageName = 'page', $page = null);
  • simplePaginate($criteria = [], $perPage = null, $columns = ['*'], $pageName = 'page', $page = null);
  • count($criteria = [], $columns = '*');
  • min($criteria, $column);
  • max($criteria, $column);
  • sum($criteria, $column);
  • avg($criteria, $column);
  • average($criteria, $column);
  • matching($criteria);
  • getQuery($criteria = []);
  • getModel();
  • newQuery();

Recca0120\Repository\Criteria

  • static create()
  • static expr($value)
  • static raw($value)
  • select($columns = ['*'])
  • selectRaw($expression, array $bindings = [])
  • selectSub($query, $as)
  • addSelect($column)
  • distinct()
  • from($table)
  • join($table, $first, $operator = null, $second = null, $type = 'inner', $where = false)
  • joinWhere($table, $first, $operator, $second, $type = 'inner')
  • leftJoin($table, $first, $operator = null, $second = null)
  • leftJoinWhere($table, $first, $operator, $second)
  • rightJoin($table, $first, $operator = null, $second = null)
  • rightJoinWhere($table, $first, $operator, $second)
  • crossJoin($table, $first = null, $operator = null, $second = null)
  • mergeWheres($wheres, $bindings)
  • tap($callback)
  • where($column, $operator = null, $value = null, $boolean = 'and')
  • orWhere($column, $operator = null, $value = null)
  • whereColumn($first, $operator = null, $second = null, $boolean = 'and')
  • orWhereColumn($first, $operator = null, $second = null)
  • whereRaw($sql, $bindings = [], $boolean = 'and')
  • orWhereRaw($sql, array $bindings = [])
  • whereIn($column, $values, $boolean = 'and', $not = false)
  • orWhereIn($column, $values)
  • whereNotIn($column, $values, $boolean = 'and')
  • orWhereNotIn($column, $values)
  • whereNull($column, $boolean = 'and', $not = false)
  • orWhereNull($column)
  • whereNotNull($column, $boolean = 'and')
  • whereBetween($column, array $values, $boolean = 'and', $not = false)
  • orWhereBetween($column, array $values)
  • whereNotBetween($column, array $values, $boolean = 'and')
  • orWhereNotBetween($column, array $values)
  • orWhereNotNull($column)
  • whereDate($column, $operator, $value = null, $boolean = 'and')
  • orWhereDate($column, $operator, $value)
  • whereTime($column, $operator, $value, $boolean = 'and')
  • orWhereTime($column, $operator, $value)
  • whereDay($column, $operator, $value = null, $boolean = 'and')
  • whereMonth($column, $operator, $value = null, $boolean = 'and')
  • whereYear($column, $operator, $value = null, $boolean = 'and')
  • whereNested(Closure $callback, $boolean = 'and')
  • addNestedWhereQuery($query, $boolean = 'and')
  • whereExists(Closure $callback, $boolean = 'and', $not = false)
  • orWhereExists(Closure $callback, $not = false)
  • whereNotExists(Closure $callback, $boolean = 'and')
  • orWhereNotExists(Closure $callback)
  • addWhereExistsQuery(Builder $query, $boolean = 'and', $not = false)
  • dynamicWhere($method, $parameters)
  • groupBy()
  • having($column, $operator = null, $value = null, $boolean = 'and')
  • orHaving($column, $operator = null, $value = null)
  • havingRaw($sql, array $bindings = [], $boolean = 'and')
  • orHavingRaw($sql, array $bindings = [])
  • orderBy($column, $direction = 'asc')
  • orderByDesc($column)
  • latest($column = 'created_at')
  • oldest($column = 'created_at')
  • inRandomOrder($seed = '')
  • orderByRaw($sql, $bindings = [])
  • skip($value)
  • offset($value)
  • take($value)
  • limit($value)
  • forPage($page, $perPage = 15)
  • forPageAfterId($perPage = 15, $lastId = 0, $column = 'id')
  • union($query, $all = false)
  • unionAll($query)
  • lock($value = true)
  • lockForUpdate()
  • sharedLock()
  • when($value, $callback, $default = null)
  • unless($value, $callback, $default = null)
  • whereKey($id)
  • whereKeyNot($id)
  • with($relations)
  • without($relations)
  • setQuery($query)
  • setModel(Model $model)
  • has($relation, $operator = '>=', $count = 1, $boolean = 'and', Closure $callback = null)
  • orHas($relation, $operator = '>=', $count = 1)
  • doesntHave($relation, $boolean = 'and', Closure $callback = null)
  • whereHas($relation, Closure $callback = null, $operator = '>=', $count = 1)
  • orWhereHas($relation, Closure $callback = null, $operator = '>=', $count = 1)
  • whereDoesntHave($relation, Closure $callback = null)
  • withCount($relations)
  • mergeConstraintsFrom(Builder $from)
  • withTrashed()
  • withoutTrashed()
  • onlyTrashed()

Usage

Eloquent

Create a Model

Create your model normally, but it is important to define the attributes that can be filled from the input form data.


namespace App;

use Illuminate\Database\Eloquent\Model;

class Post extends Model
{
    protected $fillable = [
        'title',
        'author',
     ];
}

Create a Contract


namespace App\Repositories\Contracts;

interface PostRepository
{

}

Create a Repository


namespace App\Repositories;

use App\Repositories\Contracts\PostRepository as PostRepositoryContract;
use App\Post;
use Recca0120\Repository\EloquentRepository;

class PostRepository extends EloquentRepository implements PostRepositoryContract
{
    public function __construct(Post $model)
    {
        $this->model = $model;
    }
}

Bind


namespace App\Providers;

use Illuminate\Support\ServiceProvider;
use App\Repositories\Contracts\PostRepository as PostRepositoryContract;

class AppServiceProvider extends ServiceProvider
{
    public function register()
    {
        $this->app->singleton(PostRepositoryContract::class, PostRepository::class);
    }
}

Controller


namespace App\Http\Controllers;

use App\Repositories\Contracts\PostRepository;

class PostsController extends Controller
{
    protected $repository;

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

Methods

Find all results in Repository

$posts = $this->repository->get();

Find all results in Repository with pagination

$posts = $this->repository->paginate();

Count results in Repository

$posts = $this->repository->count();

Create new entry in Repository

$post = $this->repository->create(request()->all());

Update entry in Repository

$post = $this->repository->update($id, request()->all());

Delete entry in Repository

$this->repository->delete($id);

New instance

$post = $this->repository->newInstance([
    'author' => 'author'
]);

Return Model With Conditions

$model = $this->repository->matching(Criteria::create()->where('title', '=', 'title'));

Find result by id

$post = $this->repository->find($id);

Find by conditions

Using the Criteria

Criteria is support all of Eloquent functions

Single Criteria

use Recca0120\Repository\Criteria;

$criteria = Criteria::create()
    ->select('*')
    ->where('author', '=', 'author')
    ->orWhere('title', '=', 'title')
    ->orderBy('author', 'asc');

$this->repository->get($criteria);
$this->repository->paginate($criteria);

Multiple Criteria


use Recca0120\Repository\Criteria;

$criteria = [];

$criteria[] = Criteria::create()
    ->orderBy('author', 'asc');

$criteria[] = Criteria::create()
    ->where('author', '=', 'author')
    ->orWhere('title', '=', 'title');

$this->repository->get($criteria);
// $this->repository->paginate($criteria);
With

use Recca0120\Repository\Criteria;

$criteria = Criteria::create()
    ->with('author', function($criteria) {
        $criteria->where('author', 'author');
    });

$this->repository->get($criteria);
// $this->repository->paginate($criteria);

Join


use Recca0120\Repository\Criteria;

$criteria = Criteria::create()
    ->join('author', function ($criteria) {
        $criteria->on('posts.author_id', '=', 'author.id');
    });

$this->repository->get($criteria);
// $this->repository->paginate($criteria);

Expression


use Recca0120\Repository\Criteria;

$criteria = Criteria::create()
    ->where('created_at', '<=', Criteria::expr('NOW()'));

$this->repository->get($criteria);
// $this->repository->paginate($criteria);

Custom Criteria


use Recca0120\Repository\Criteria;

class CustomCriteria extends Criteria
{
    public function __construct($id)
    {
        $this->where('id', '=', $id);
    }
}

$this->repository->get((new CustomCriteria(1))->where('autor', 'autor'));

ToDo

  • Cache