PHP code example of litepie / repository

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

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

    

litepie / repository example snippets

namespace App\Http\Controllers;

use App\Repositories\Contracts\UserRepositoryInterface;

class UserController extends Controller
{
    public function __construct(
        private UserRepositoryInterface $userRepository
    ) {}

    public function index()
    {
        $users = $this->userRepository->paginate(15);
        return view('users.index', compact('users'));
    }

    public function store(Request $request)
    {
        $user = $this->userRepository->create($request->validated());
        return redirect()->route('users.show', $user);
    }
}

// Create
$user = $userRepository->create(['name' => 'John Doe', 'email' => '[email protected]']);

// Read
$user = $userRepository->find(1);
$users = $userRepository->all();

// Update
$user = $userRepository->update(1, ['name' => 'Jane Doe']);

// Delete
$userRepository->delete(1);

// Find with relationships
$user = $userRepository->with(['posts', 'comments'])->find(1);

// Search and filter
$users = $userRepository
    ->where('status', 'active')
    ->orderBy('created_at', 'desc')
    ->paginate(10);

// Custom queries
$users = $userRepository->findWhere([
    ['status', '=', 'active'],
    ['created_at', '>', now()->subDays(30)]
]);

// Advanced filtering
$users = $userRepository
    ->filter(['status' => 'active', 'role' => ['admin', 'moderator']])
    ->search('john', ['name', 'email'])
    ->dateRange('created_at', '2024-01-01', '2024-12-31')
    ->get();

// Request-based filtering
$users = $userRepository
    ->filterFromRequest(request()->all(), ['name', 'email', 'status'])
    ->sortFromRequest(request()->all(), ['name', 'created_at'])
    ->paginate(15);

// Join tables
$posts = $postRepository
    ->select(['posts.*', 'users.name as author_name'])
    ->join('users', 'posts.user_id', '=', 'users.id')
    ->where('posts.status', 'published')
    ->orderBy('posts.created_at', 'desc')
    ->get();

// Complex joins with conditions
$posts = $postRepository
    ->select(['posts.*', 'users.name as author_name'])
    ->selectRaw('COUNT(comments.id) as comments_count')
    ->join('users', 'posts.user_id', '=', 'users.id')
    ->leftJoin('comments', 'posts.id', '=', 'comments.post_id')
    ->where('posts.status', 'published')
    ->groupBy(['posts.id', 'users.name'])
    ->having('comments_count', '>', 5)
    ->orderByRaw('comments_count DESC')
    ->get();

namespace App\Repositories;

use App\Models\User;
use App\Repositories\Contracts\UserRepositoryInterface;
use Litepie\Repository\BaseRepository;

class UserRepository extends BaseRepository implements UserRepositoryInterface
{
    public function model(): string
    {
        return User::class;
    }

    public function findActiveUsers()
    {
        return $this->where('status', 'active')->get();
    }

    public function findByEmail(string $email)
    {
        return $this->where('email', $email)->first();
    }

    public function getRecentUsers(int $days = 30)
    {
        return $this->where('created_at', '>=', now()->subDays($days))
                   ->orderBy('created_at', 'desc')
                   ->get();
    }
}

namespace App\Providers;

use Illuminate\Support\ServiceProvider;
use App\Repositories\UserRepository;
use App\Repositories\Contracts\UserRepositoryInterface;

class AppServiceProvider extends ServiceProvider
{
    public function register()
    {
        $this->app->bind(UserRepositoryInterface::class, UserRepository::class);
    }
}

// Much faster than OFFSET pagination for large datasets
$users = $userRepository
    ->where('status', 'active')
    ->cursorPaginate(20);

// For APIs
return response()->json([
    'data' => $users->items(),
    'next_cursor' => $users->nextCursor()?->encode(),
    'has_more' => $users->hasMorePages(),
]);

// Skip expensive COUNT(*) queries
$users = $userRepository
    ->where('status', 'active')
    ->fastPaginate(20);

// Automatically chooses the best pagination method based on dataset size
$users = $userRepository
    ->where('status', 'active')
    ->smartPaginate(20);

// Process large datasets without memory issues
$userRepository->chunk(1000, function ($users) {
    foreach ($users as $user) {
        // Process each user
    }
});

// Or use lazy collections
$users = $userRepository->lazy(1000);
foreach ($users as $user) {
    // Memory-efficient iteration
}

// Parse filter string like:
// "category:IN(Apartment,Bungalow);price:BETWEEN(100000,500000);status:EQ(Published);bua:GT(1000)"

$properties = $propertyRepository
    ->parseQueryFilters($filterString, ['category', 'price', 'status', 'bua'])
    ->cursorPaginate(20);

// URL: /api/properties?filters=category:IN(Apartment,Villa);price:BETWEEN(100000,500000);bedrooms:IN(2,3,4)

public function search(Request $request, PropertyRepository $repository)
{
    $filterString = $request->get('filters');
    
    // Security: Define allowed fields
    $allowedFields = ['category', 'price', 'bedrooms', 'status', 'location'];
    
    $properties = $repository
        ->parseQueryFilters($filterString, $allowedFields)
        ->with(['images', 'location'])
        ->optimizedPaginate(20);
        
    return response()->json([
        'data' => $properties->items(),
        'filters' => $repository->getFilterSummary($filterString),
    ]);
}

// Statistical analysis
$stats = $repository->statisticalSummary('revenue');
$trends = $repository->trend('created_at', 'day', 'sales', 'sum');
$correlation = $repository->correlation('price', 'rating');

// Pivot tables
$salesData = $repository->pivot('category', 'month', 'revenue', 'sum');

// Multi-engine search (Database, Elasticsearch, Algolia)
$results = $repository
    ->configureSearch(['engine' => 'elasticsearch'])
    ->search('laravel repository pattern');

// Fuzzy search with similarity matching
$fuzzyResults = $repository->fuzzySearch('jhon doe', 0.8);

// Handle large datasets efficiently
$repository->bulkInsert($millionRecords, 2000);
$repository->bulkUpsert($data, ['email'], ['name', 'status']);
$repository->batchProcess($callback, 1000);

// Advanced caching with tags and auto-invalidation
$data = $repository
    ->remember(3600)
    ->tags(['users', 'active'])
    ->where('status', 'active')
    ->get();

// Built-in profiling and optimization
$repository->enableProfiling();
$data = $repository->complexQuery();
$report = $repository->getPerformanceReport();

// Stream large exports
return $repository->streamExport('csv');

// Bulk import with conflict resolution
$imported = $repository->importFromCsv('data.csv', $mapping, [
    'update_existing' => true,
    'skip_errors' => true
]);

// Listen to repository events
Event::listen('repository.User.created', function ($model) {
    // Send notifications, update caches, etc.
});

// Advanced relationship operations
$repository->syncRelation('tags', $postId, [1, 2, 3]);
$repository->createRelated('comments', $postId, $commentData);
$repository->loadMissingRelations($collection, ['user', 'tags']);

bash
php artisan make:repository UserRepository

bash
php artisan vendor:publish --provider="Litepie\Repository\RepositoryServiceProvider" --tag="config"