PHPackages                             juankno/laravel-repository - PHPackages - PHPackages  [Skip to content](#main-content)[PHPackages](/)[Directory](/)[Categories](/categories)[Trending](/trending)[Leaderboard](/leaderboard)[Changelog](/changelog)[Analyze](/analyze)[Collections](/collections)[Log in](/login)[Sign up](/register)

1. [Directory](/)
2. /
3. [Utility & Helpers](/categories/utility)
4. /
5. juankno/laravel-repository

ActiveLibrary[Utility & Helpers](/categories/utility)

juankno/laravel-repository
==========================

A Laravel package to easily implement the Repository Pattern with automatic binding and generation.

v1.7.0(8mo ago)3330MITPHPPHP >=8.1

Since Mar 15Pushed 3mo ago1 watchersCompare

[ Source](https://github.com/juankno/laravel-repository)[ Packagist](https://packagist.org/packages/juankno/laravel-repository)[ RSS](/packages/juankno-laravel-repository/feed)WikiDiscussions main Synced 1mo ago

READMEChangelogDependencies (2)Versions (18)Used By (0)

Laravel Repository
==================

[](#laravel-repository)

🌎 Read this in [Spanish](README.es.md).

This package simplifies working with the **Repository Pattern** in Laravel by automatically generating repository files, contracts, and bindings.

🆕 **New in v1.7.0** - Simple by Default
---------------------------------------

[](#-new-in-v170---simple-by-default)

The command behavior has been improved to follow the **principle of least surprise**:

- **Default**: Creates a basic repository with essential CRUD methods (find, getAll, create, update, delete)
- **Advanced**: Use `--full` flag to get all advanced features (filtering, scoping, bulk operations, etc.)

This makes the package more beginner-friendly while keeping all the power for advanced users.

Installation
------------

[](#installation)

Install the package using Composer:

```
composer require juankno/laravel-repository
```

Configuration
-------------

[](#configuration)

If Laravel does not auto-discover the package, manually register the `RepositoryServiceProvider` in `config/app.php`:

```
'providers' => [
    Juankno\Repository\Providers\RepositoryServiceProvider::class,
],
```

Publishing the Repository Service Provider
------------------------------------------

[](#publishing-the-repository-service-provider)

If you want to customize the `RepositoryServiceProvider`, you can publish it using:

```
php artisan vendor:publish --tag=repository-provider
```

Usage
-----

[](#usage)

### Creating a Repository

[](#creating-a-repository)

To generate a basic repository (recommended), run the following Artisan command:

```
php artisan make:repository UserRepository
```

This creates a simple repository with basic CRUD operations (find, getAll, create, update, delete).

If you want to associate it with a specific model:

```
php artisan make:repository UserRepository User
```

For a repository with **all advanced methods and features**, use the `--full` option:

```
php artisan make:repository UserRepository User --full
```

### Generating a Base Repository

[](#generating-a-base-repository)

You can generate an abstract `BaseRepository` class along with its interface to avoid code duplication:

```
php artisan make:repository UserRepository User --abstract
```

This will create a `BaseRepository` and `BaseRepositoryInterface` in your application, which other repositories can extend.

### Creating a Full-Featured Repository

[](#creating-a-full-featured-repository)

If you need all advanced features and methods, use the `--full` option:

```
php artisan make:repository UserRepository --full
```

This creates a repository with all available methods including advanced filtering, scoping, bulk operations, and more.

Available Commands
------------------

[](#available-commands)

### `make:repository`

[](#makerepository)

This command generates a repository along with its contract and implementation.

#### **Usage:**

[](#usage-1)

```
php artisan make:repository {name} {model?} {--force} {--abstract} {--full} {--no-traits}
```

#### **Arguments:**

[](#arguments)

- `name` *(required)*: The name of the repository.
- `model` *(optional)*: The associated Eloquent model.

#### **Options:**

[](#options)

- `--force`: Overwrite existing files if they already exist.
- `--abstract`: Generate a BaseRepository and BaseRepositoryInterface.
- `--full`: Create a repository with all advanced methods and features.
- `--no-traits`: Create a repository with implementation without using traits.

#### **Examples:**

[](#examples)

```
# Create a basic repository (recommended for most cases)
php artisan make:repository UserRepository User

# Create a repository with all advanced methods
php artisan make:repository UserRepository User --full

# Create a repository in a subfolder
php artisan make:repository Admin/UserRepository User

# Create a repository and generate BaseRepository
php artisan make:repository UserRepository User --abstract

# Force overwrite of existing files
php artisan make:repository UserRepository User --force

# Create repository without traits (direct implementation)
php artisan make:repository UserRepository User --no-traits
```

Available Repository Methods
----------------------------

[](#available-repository-methods)

### Basic Repository Methods (Default)

[](#basic-repository-methods-default)

Each basic repository includes these essential CRUD methods:

- `find(int $id)`: Find a record by ID.
- `getAll()`: Get all records.
- `create(array $data)`: Create a new record.
- `update(int $id, array $data)`: Update a record.
- `delete(int $id)`: Delete a record.

### Full Repository Methods (--full option)

[](#full-repository-methods---full-option)

When using the `--full` option, repositories include all these advanced methods:

- `all(array $columns = ['*'], array $relations = [], array $orderBy = [])`: Get all records.
- `find(int $id, array $columns = ['*'], array $relations = [], array $appends = [])`: Find a record by ID.
- `findBy(string $field, $value, array $columns = ['*'], array $relations = [])`: Find a record by a specific field.
- `findWhere(array $conditions, array $columns = ['*'], array $relations = [], array $orderBy = [])`: Find records matching conditions.
- `paginate(int $perPage = 15, array $columns = ['*'], array $relations = [], array $orderBy = [], array $conditions = [])`: Paginate records.
- `create(array $data)`: Create a new record.
- `update(int $id, array $data)`: Update a record.
- `delete(int $id)`: Delete a record.
- `first(array $conditions = [], array $columns = ['*'], array $relations = [], array $orderBy = [])`: Get the first record matching conditions.
- `createMany(array $data)`: Create multiple records in a single operation.
- `updateWhere(array $conditions, array $data)`: Update multiple records based on conditions.
- `deleteWhere(array $conditions)`: Delete multiple records based on conditions.

Detailed Method Examples
------------------------

[](#detailed-method-examples)

### Retrieving All Records

[](#retrieving-all-records)

```
// Get all users
$users = $userRepository->all();

// Get specific columns
$userNames = $userRepository->all(['id', 'name', 'email']);

// Get records with relations
$usersWithPosts = $userRepository->all(['*'], ['posts']);

// Get records with custom ordering
$usersByNewest = $userRepository->all(['*'], [], ['created_at' => 'desc']);

// Get records with multiple relations and ordering
$users = $userRepository->all(
    ['*'],
    ['posts', 'profile', 'roles'],
    ['name' => 'asc']
);
```

### Finding Records by ID

[](#finding-records-by-id)

```
// Find user by ID
$user = $userRepository->find(1);

// Find user with specific columns
$user = $userRepository->find(1, ['id', 'name', 'email']);

// Find user and load relations
$userWithPosts = $userRepository->find(1, ['*'], ['posts']);

// Find user with appended attributes
$userWithFullName = $userRepository->find(1, ['*'], [], ['full_name']);

// Find user with relations and appended attributes
$user = $userRepository->find(
    1,
    ['*'],
    ['posts', 'comments'],
    ['full_name', 'post_count']
);
```

### Finding Records by a Specific Field

[](#finding-records-by-a-specific-field)

```
// Find user by email
$user = $userRepository->findBy('email', 'john@example.com');

// Find user by username with specific columns
$user = $userRepository->findBy('username', 'johndoe', ['id', 'username', 'email']);

// Find user with relations
$user = $userRepository->findBy('email', 'john@example.com', ['*'], ['posts', 'profile']);
```

### Finding Records with Conditions

[](#finding-records-with-conditions)

```
// Find active users
$activeUsers = $userRepository->findWhere(['status' => 'active']);

// Find users with specific role
$adminUsers = $userRepository->findWhere(['role' => 'admin'], ['id', 'name', 'email']);

// Using operators in conditions
$recentUsers = $userRepository->findWhere([
    ['created_at', '>=', now()->subDays(7)]
]);

// Find users with multiple conditions and load relations
$users = $userRepository->findWhere(
    [
        'status' => 'active',
        ['age', '>', 18]
    ],
    ['*'],
    ['posts', 'profile']
);

// Find users with specific IDs (whereIn)
$specificUsers = $userRepository->findWhere(['id' => [1, 2, 3]]);

// Find with custom ordering
$users = $userRepository->findWhere(
    ['status' => 'active'],
    ['*'],
    ['profile'],
    ['name' => 'asc']
);
```

### Paginating Records

[](#paginating-records)

```
// Paginate users (15 per page by default)
$paginatedUsers = $userRepository->paginate();

// Custom pagination
$paginatedUsers = $userRepository->paginate(25);

// Paginate with specific columns
$paginatedUsers = $userRepository->paginate(10, ['id', 'name', 'email']);

// Paginate and load relations
$paginatedUsers = $userRepository->paginate(20, ['*'], ['posts']);

// Paginate with conditions
$paginatedActiveUsers = $userRepository->paginate(
    15,
    ['*'],
    [],
    ['created_at' => 'desc'],
    ['status' => 'active']
);

// Display paginated results in a view
return view('users.index', compact('paginatedUsers'));
```

### Creating Records

[](#creating-records)

```
// Create a new user
$userData = [
    'name' => 'John Doe',
    'email' => 'john@example.com',
    'password' => bcrypt('password')
];
$user = $userRepository->create($userData);

// Create and use immediately
$post = $postRepository->create([
    'title' => 'New Post',
    'content' => 'Post content',
    'user_id' => $user->id
]);
```

### Creating Multiple Records

[](#creating-multiple-records)

```
// Create multiple users at once
$usersData = [
    [
        'name' => 'John Doe',
        'email' => 'john@example.com',
        'password' => bcrypt('password')
    ],
    [
        'name' => 'Jane Smith',
        'email' => 'jane@example.com',
        'password' => bcrypt('password')
    ]
];

$users = $userRepository->createMany($usersData);

// Access the created models
foreach ($users as $user) {
    echo $user->id . ': ' . $user->name . "\n";
}
```

### Updating Records

[](#updating-records)

```
// Update a user
$updatedUser = $userRepository->update(1, [
    'name' => 'Updated Name',
    'email' => 'updated@example.com'
]);

// Check if update was successful
if ($updatedUser) {
    // Update successful, $updatedUser contains the fresh model instance
} else {
    // Update failed or user not found
}
```

### Updating Records in Bulk

[](#updating-records-in-bulk)

```
// Update all active users to have a verified status
$updated = $userRepository->updateWhere(
    ['status' => 'active'],
    ['is_verified' => true]
);

// Update users with specific role and created before a certain date
$updated = $userRepository->updateWhere(
    [
        'role' => 'customer',
        ['created_at', 'deleteWhere([
    ['last_login_at', '', now()]
    ],
    ['*'],
    ['subscription'],
    ['created_at' => 'desc']
);
```

Working with Relations
----------------------

[](#working-with-relations)

The repository pattern can be combined with Laravel's Eloquent relationships:

```
// Get all posts for a user
$user = $userRepository->find(1, ['*'], ['posts']);
$posts = $user->posts;

// Filter users by their relation data
$userWithManyPosts = $userRepository->findWhere([
    ['posts_count', '>', 5]
]);

// Using nested relations
$userWithData = $userRepository->find(1, ['*'], ['posts.comments', 'profile']);
```

Working with Eloquent Scopes
----------------------------

[](#working-with-eloquent-scopes)

This package supports the use of Eloquent scopes to simplify your queries. Scopes are an excellent way to reuse query logic across different parts of your application.

### Defining Scopes in Your Models

[](#defining-scopes-in-your-models)

First, define the scopes in your Eloquent model following Laravel conventions:

```