PHP code example of ttpn18121996 / simple-repository

    
        
<?php
require_once('vendor/autoload.php');

/* Start to develop here. Best regards https://php-download.com/ */

    

ttpn18121996 / simple-repository example snippets

protected $repositories = [
    ...
    \App\Repositories\Contracts\UserRepository::class => \App\Repositories\Eloquent\UserRepository::class,
]

namespace App\Repositories\Eloquent;

use App\Models\Province;
use App\Repositories\Contracts\ProvinceRepository as ProvinceRepositoryContract;

class ProvinceRepository implements ProvinceRepositoryContract
{
    public function getDataSource()
    {
        return new Province();
    }

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

namespace App\Repositories\Api;

use App\Repositories\Contracts\ProvinceRepository as ProvinceRepositoryContract;
use Illuminate\Support\Facades\Http;

class ProvinceRepository implements ProvinceRepositoryContract
{
    public function getDataSource()
    {
        return Http::baseUrl('https://api.domain.example');
    }

    public function all()
    {
        $response = $this->getDataSource()->get('/provinces');

        return $response->success() ? $response->collection() : collect();
    }
}

protected $repositories = [
    ...
    // \App\Repositories\Contracts\ProvinceRepository::class => \App\Repositories\Eloquent\ProvinceRepository::class,
    \App\Repositories\Contracts\ProvinceRepository::class => \App\Repositories\Api\ProvinceRepository::class,
]

use SimpleRepository\Concerns\HasFilter;

class UserService extends Service
{
    use HasFilter;
}

use Illuminate\Contracts\Database\Query\Builder;
use SimpleRepository\FilterAdapter;
use SimpleRepository\FilterDTO;

protected function buildFilter(Builder $query, array|FilterDTO $filters = []): Builder
{
    $filters = $filters instanceof FilterDTO ? $filters : FilterAdapter::makeDTO($filters);

    // ...
}

use App\Models\User;
use App\Repositories\Eloquent\UserRepository as UserRepositoryContract;
use SimpleRepository\Concerns\HasEloquentSupport;

class UserRepository implements UserRepositoryContract
{
    use HasEloquentSupport;

    protected ?string $modelName = User::class;
}

$users = app(\App\Repositories\Contracts\UserRepository::class)->getPagination($filters);

protected function buildRelationships(): Builder
{
    return $this->model()->with(['roles', 'permissions']);
}

// Get a paginated list of users with roles and permissions for each user.
$users = app(\App\Repositories\Contracts\UserRepository::class)->getPagination($filters);

protected function getBuilder(Builder $query, array $filters = []): Builder
{
    return $query->with(['roles', 'permissions'])
        ->when(Arr::get($filters, 'name'), function (Builder $query, $name) {
            $query->where('name', 'like', "%{$name}%");
        })
        ->orderBy('name');
}

class UserController
{
    public function index(Request $request)
    {
        $users = $this->userService
            ->useAuthUser($request->user())
            ->getList($request->query());
        ...
    }
}

class UserService extends Service
{
    public function getList(array $filters = [])
    {
        if ($this->authUser()->can('view_user')) {
            // Do something
        }
        ...
    }
}

$this->buildFilter(query: $query, filters: [
    'search' => [ // Relative search (operator "like")
        'field_1' => 'value1',
        'field_2' => 'value2',
    ],
    'or_search' => [ // Relative search (operator "like"). Use the "orWhere" method
        'field_1' => 'value1',
        'field_2' => 'value2',
    ],
    'filter' => [ // Absolute search (operator "=")
        'field_1' => 'value1',
        'field_2' => 'value2',
    ],
    'or_filter' => [ // Absolute search (operator "="). Use the "orWhere" method
        'field_1' => 'value1',
        'field_2' => 'value2',
    ],
    'sort' => [ // Sort data
        'field' => 'field_name',
        'direction' => 'asc' // asc | desc
    ],
    // If the value is null, the records that have not been deleted will be queried.
    // Otherwise, the query will be based on the column name with the value not null.
    'deleted' => 'deleted_at', // by default is null
]);

use SimpleRepository\FilterDTO;
use SimpleRepository\Enums\SortDirection;

new FilterDTO(
    page: 1,
    perPage: 10,
    search: [
        'field_1' => 'value1',
        'field_2' => 'value2',
    ],
    orSearch: [
        'field_1' => 'value1',
        'field_2' => 'value2',
    ],
    filter: [
        'field_1' => 'value1',
        'field_2' => 'value2',
    ],
    orFilter: [
        'field_1' => 'value1',
        'field_2' => 'value2',
    ],
    sortField: 'field_name',
    sortDirection: SortDirection::tryFrom('asc') ?? SortDirection::ASC,
    deleted: 'deleted_at',
);

use SimpleRepository\FilterAdapter;


public function index(Request $request)
{
    $filterDTO = FilterAdapter::makeDTO($request);
}

namespace App\Services;

class UserService extends Service
{
    protected array $transferredFields = [
        'name' => 'users.name',
        'role_name' => 'roles.name',
    ];
}

namespace App\Services;

class UserService extends Service
{
    protected function getTransferredField(string $field): string
    {
        return [
            'name' => 'users.name',
            'role_name' => 'roles.name',
        ][$field] ?? $field;
    }
}

namespace App\Services;

use App\Models\User;

class UserService extends Service
{
    public function __construct(
        public User $user,
    ) {
    }

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

namespace App\Services;

use App\Models\User;
use SimpleRepository\Attributes\ModelFactory;

class UserService extends Service
{
    #[ModelFactory(User::class)]
    public ?User $user = null;

    public function getById($id)
    {
        return $this->getModel('user')->find($id);
    }
}

DB::beginTransaction();

try {
    // Do something
    DB::commit();

    return $data;
} catch (\Throwable $e) {
    DB::rollback();
    logger()->error($e->getMessage());

    return null;
}

use SimpleRepository\Concerns\Safetyable;

class MyClass
{
    use Safetyable;

    public function doSomething($params)
    {
        return $this->handleSafely(function () {
            // Do something

            return $data;
        }, 'Do something');
    }
}

class UserService extends Service
{
    #[ModelFactory(User::class)]
    protected ?User $user = null;

    public function create(array $data)
    {
        return $this->handleSafely(function () use ($data) {
            $user = $this->getModel('user', $data);
            $user->save();

            return $user;
        }, 'Create user');
    }
}

return [
    ...
    'log_channel' => 'stack',
];

namespace App\Services\UserService;

public function sampleMethod()
{
    /**
     * @var \App\Services\RoleService
     */
    $roleService = $this->getService('RoleService');
}

namespace App\Services\UserService;

use App\Services\RoleService;
use SimpleRepository\Attributes\ServiceFactory;

class UserService extends Service
{
    #[ServiceFactory(RoleService::class)]
    public ?RoleService $role = null;

    public function sampleMethod()
    {
        /**
         * @var \App\Services\RoleService
         */
        $roleService = $this->getService('role');
    }
}

bash
php artisan simple-repository:install

bash
php artisan make:repository UserRepository

bash
php artisan make:repository UserRepository --model=User

#OR

php artisan make:repository UserRepository -m User

bash
php artisan make:repository UserRepository --repo Api

#OR

php artisan make:repository UserRepository -r Api

text
/app
├---/Providers
|   ├---RepositoryServiceProvider.php
├---/Repositories
|   ├---/Api
|   |   ├---ProvinceRepository.php
|   ├---/Contracts
|   |   ├---ProvinceRepository.php
|   ├---/Eloquent
|   |   ├---ProvinceRepository.php

bash
php artisan make:service UserService

bash
php artisan make:service UserService --repo=UserRepository --repo=RoleRepository

#OR

php artisan make:service UserService -r UserRepository -r RoleRepository