PHPackages                             odysee/iliad - 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. odysee/iliad

ActiveLibrary

odysee/iliad
============

A base module for developing rest APIs in PHP with Eloquent.

0.1.5(4mo ago)023MITPHPPHP ^8.3

Since Mar 3Pushed 4mo ago1 watchersCompare

[ Source](https://github.com/IlyasDeckers/iliad)[ Packagist](https://packagist.org/packages/odysee/iliad)[ RSS](/packages/odysee-iliad/feed)WikiDiscussions master Synced 1mo ago

READMEChangelog (6)Dependencies (3)Versions (7)Used By (0)

Iliad Documentation
===================

[](#iliad-documentation)

Overview
--------

[](#overview)

Iliad is a PHP package built on top of Laravel's Eloquent ORM that provides a structured approach to developing REST APIs. It implements the repository pattern to create an abstraction layer between controllers and models, making your codebase more maintainable and testable.

Core Components
---------------

[](#core-components)

### Repositories

[](#repositories)

Repositories are the heart of Iliad, providing a clean interface for data access and manipulation. They encapsulate the logic required to interact with data sources.

#### BaseRepository (Deprecated)

[](#baserepository-deprecated)

> **DEPRECATED**: This class is deprecated and should not be used in new code. Use `_BaseRepository` instead.

The original base repository implementation that provides common methods for interacting with Eloquent models.

```
namespace Iliad\Repositories;

abstract class BaseRepository
{
    // Common repository methods
    public function find(object $request): object;
    public function getAll(object $request): object;
    // ...
}
```

#### \_BaseRepository

[](#_baserepository)

The current implementation of the repository pattern that leverages PHP 8 features and provides a more robust implementation.

```
namespace Iliad\Repositories;

abstract class _BaseRepository
{
    use Transaction, QueryBuilder;

    protected Model $model;
    protected string $dataClass;

    // Core methods
    public function getAll(): DataCollection;
    public function find(int $id): Data;
    // ...
}
```

Key features:

- Strong typing with PHP 8 features
- Better integration with Laravel's ecosystem
- Enhanced transaction handling via `TransactionManager`
- Integration with Spatie's Laravel Data package

#### Implementing a Repository

[](#implementing-a-repository)

When implementing a repository, you should extend `_BaseRepository` and implement the necessary methods:

```
namespace App\Repositories;

use App\Dto\UserData;
use App\Interfaces\UserRepositoryInterface;
use App\Models\User;
use Iliad\Transactions\Transaction;
use Iliad\Repositories\_BaseRepository;
use Iliad\Repositories\Concerns\QueryBuilder;
use Iliad\Transactions\TransactionManager;

class UserRepository extends _BaseRepository implements UserRepositoryInterface
{
    use Transaction,
        QueryBuilder;

    protected string $dataClass = UserData::class;

    public function __construct(
        User $userModel,
        TransactionManager $transactionManager
    )
    {
        $this->transactionManager = $transactionManager;
        parent::__construct();
        $this->model = $userModel;
    }

    public function store(UserData $userData): UserData
    {
        $this->model->create($userData);

        $this->transactionManager->commit();

        return $results['model']->refresh()->getData();
    }

    public function update(UserData $userData): UserData
    {
        $user = $this->model->findOrFail($userData->id);

        // Update logic here

        $this->transactionManager->commit();

        return $user->refresh()->getData();
    }

    public function destroy(int $id): void
    {
        // Delete logic here
    }
}
```

### Transaction Management

[](#transaction-management)

Iliad provides robust transaction handling to ensure database integrity.

#### Transaction Trait

[](#transaction-trait)

The `Transaction` trait provides methods for managing database transactions:

```
namespace Iliad\Transactions;

trait Transaction
{
    public ?TransactionManager $transactionManager = null;

    private function getTransactionManager(): TransactionManager;
    private function startTransactions(): void;
    private function commitTransactions(): void;
    private function flush(): void; // Deprecated, use commitTransactions() instead
    // ...
}
```

Key features:

- Automatic transaction start for non-GET requests
- Integration with the `TransactionManager` class
- Automatic rollback on exceptions

#### TransactionManager

[](#transactionmanager)

The transaction management system that provides control and error handling:

```
namespace Iliad\Transactions;

class TransactionManager
{
    public function beginTransaction(): void;
    public function commit(): void;
    public function rollback(): void;
    public function transaction(callable $callback): mixed;
    // ...
}
```

Key features:

- Tracks active transactions
- Provides a clean API for transaction management
- Supports nested transactions
- Includes a `transaction()` method for executing code within a transaction

### Query Builder Concern

[](#query-builder-concern)

The `QueryBuilder` trait provides methods for building and executing queries:

```
namespace Iliad\Repositories\Concerns;

trait QueryBuilder
{
    public function collectionResponse(Builder|Model $query): DataCollection;
    public function createCollection(Builder|Model $query): DataCollection;
    public function createDataCollection(Builder|Model $query): DataCollection;
    private function parseQueryDataToQuery(Builder|Model $query, QueryStringData $queryData): Builder;
    public function sort(Builder $query, Request $request): Builder;
    public function noSort(Builder $query): Builder;
    // ...
}
```

Key features:

- Transform queries into data collections
- Parse query string parameters
- Apply sorting, filtering, and other operations

### Data Transfer Objects

[](#data-transfer-objects)

Iliad uses Data Transfer Objects (DTOs) to encapsulate data and provide a consistent interface.

#### Dto

[](#dto)

The base DTO class that provides common functionality:

```
namespace Iliad\DataTransferObjects;

class Dto
{
    use StaticCreateFrom, StaticCreateDataCollection, ToArray;
}
```

Key features:

- Convert to and from arrays
- Create collections of DTOs
- Static factory methods

### Controllers

[](#controllers)

Iliad provides base controllers that integrate with repositories to handle HTTP requests.

#### BaseController (Deprecated)

[](#basecontroller-deprecated)

> **DEPRECATED**: This class is deprecated and should not be used in new code.

The base controller that provides RESTful endpoints:

```
namespace Iliad\Http\Controllers;

abstract class BaseController extends Controller
{
    protected $model;
    protected $resource;
    protected array $rules = [];

    public function index(Request $request);
    public function show(Request $request);
    public function store(Request $request): object;
    public function update(Request $request): object;
    public function destroy(int $id): void;
    // ...
}
```

#### \_BaseController

[](#_basecontroller)

The recommended controller base class to extend for new controllers:

```
namespace Iliad\Http\Controllers;

abstract class _BaseController extends Controller
{
    // Base controller functionality
}
```

#### Controller

[](#controller)

The base controller that provides the foundation for all controllers:

```
namespace Iliad\Http\Controllers;

abstract class Controller
{
    protected array $middleware = [];

    public function middleware($middleware, array $options = []): ControllerMiddlewareOptions;
    public function getMiddleware();
    public function callAction($method, $parameters);
    // ...
}
```

#### Implementing a Controller

[](#implementing-a-controller)

Here's an example of implementing a controller that uses route attributes and integrates with a repository:

```